@redential/cli 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,217 @@
+# Redential CLI
+
+[![npm version](https://img.shields.io/npm/v/%40redential%2Fcli.svg)](https://www.npmjs.com/package/@redential/cli)
+[![CI](https://github.com/Jppblue/redential-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/Jppblue/redential-cli/actions/workflows/ci.yml)
+[![License: Apache-2.0](https://img.shields.io/badge/License-Apache--2.0-blue.svg)](LICENSE)
+
+Your best work is probably under an NDA.
+
+The years you spent building payments infrastructure, hardening auth, or
+carrying on-call — none of it can go in a portfolio, because none of it can
+leave your employer's repo. `@redential/cli` reads your **local** git
+history and turns it into a metadata-only proof: volume, span, cadence,
+languages, technical categories, signed commits, ownership share. Never
+the code itself.
+
+```bash
+npx @redential/cli scan
+```
+
+That's it — no login, no config, nothing installed globally. `scan` makes
+zero network calls (it's structurally incapable of phoning home, not just
+network-free by default — see [docs/principles.md](docs/principles.md)),
+prints the exact JSON it would ever upload, and stops there. You review it.
+If you like what you see:
+
+```bash
+npx @redential/cli login    # device flow, one time
+npx @redential/cli submit   # scans again, shows you the bundle, asks before uploading
+npx @redential/cli logout   # deletes the locally stored session
+```
+
+Prefer a persistent install:
+
+```bash
+npm install -g @redential/cli
+redential scan
+```
+
+## What `scan` looks like
+
+It prints the full JSON bundle first (see [docs/schema.md](docs/schema.md)
+for every field), then — only when stdout is an interactive terminal — a
+human-readable summary underneath it:
+
+```
+{
+  "schema_version": "1.0.0",
+  "runner": "local",
+  "tool_version": "0.1.0",
+  "created_at": "2026-07-09T14:32:01.000Z",
+  "repo": { "host_type": "github", "age_days": 742, "repo_fingerprint": "a3f9…" },
+  "identity": { "author_identity_hashes": ["9c1e…"], "other_contributors_count": 3 },
+  "commits": { "user_total": 1847, "first_at": "2024-06-02T09:14:00Z", "last_at": "2026-07-08T21:05:00Z", "span_days": 767, "hour_histogram": [...], "weekday_histogram": [...] },
+  "signed": { "count": 831, "ratio": 0.45, "key_types": ["ssh"] },
+  "languages": [ { "extension": ".ts", "share": 0.62 }, { "extension": ".sql", "share": 0.14 } ],
+  "categories": [ { "name": "backend", "commit_count": 902, "churn_share": 0.51 }, { "name": "testing", "commit_count": 340, "churn_share": 0.18 } ],
+  "detected_skills": [ { "slug": "payments/stripe", "commit_count": 12, "first_seen": "2024-09-01T10:00:00Z", "last_seen": "2025-11-20T18:30:00Z" } ],
+  "ownership": { "user_commit_ratio": 0.78 },
+  "integrity": { "merkle_root": "7be2…", "algorithm": "sha256" },
+  "attestation": { "confirmed": true, "confirmed_at": "2026-07-09T14:32:01.000Z" }
+}
+
+  ────────────────────────────────────────────────────────────
+
+  ╔════════════════════════════════════════════════════════════╗
+  ║                 YOUR PRIVATE REPO, WRAPPED                 ║
+  ╚════════════════════════════════════════════════════════════╝
+
+  2 years, 1,847 commits
+
+  COMMITS BY HOUR (UTC)
+  0     6     12    18
+  ▁····▁▁▃▅█▇▄▃▂▂▁▁▁▁▁····
+
+  COMMITS BY WEEKDAY
+  Sun  ██░░░░░░░░░░░░░░░░░░  5
+  Mon  ███████████████████░  40
+
+  TOP LANGUAGES
+  .ts    ████████████████████   62%
+  .sql   ████░░░░░░░░░░░░░░░░   14%
+
+  SKILLS DETECTED
+  payments/stripe     12 commits
+
+  Ownership       78% of this repo's commits are yours
+  Signed commits  45% of your commits are cryptographically signed
+
+  Nothing left your machine. Verify: github.com/Jppblue/redential-cli
+```
+
+Pipe it (`redential scan | jq`) or pass `--json` and you get only the raw
+JSON above — the wrapped summary is a terminal-only convenience, not a
+second source of data. Full command reference: [docs/scan.md](docs/scan.md).
+
+## Trust model
+
+| Never leaves your machine | Only travels after you run `submit`, and only this |
+|---|---|
+| Source code, diffs, snippets | The bundle printed by `scan` — byte for byte |
+| File and directory names | An extension (`.ts`) and an inferred category (`backend`) |
+| Commit messages | Aggregate cadence: hour/weekday histograms |
+| Other contributors' names or emails | An aggregate count of other contributors |
+| The remote URL | Only the host *kind* (`github`, `gitlab`, …), never the URL |
+| Secrets of any kind | Nothing — a secret-scan runs over the bundle and blocks output on any match |
+
+Every row on the left is backed by an [executable test](test/privacy/), per
+[docs/privacy-tests.md](docs/privacy-tests.md) — not just a policy
+statement. `scan` itself makes zero network calls; `login` and `submit` are
+the only two commands that touch the network at all, and `submit` uploads
+nothing without your explicit confirmation. Full rationale:
+[docs/principles.md](docs/principles.md).
+
+### Verifying the package itself
+
+Every release is published from GitHub Actions on a tagged commit with npm
+provenance (`npm publish --provenance`) — never from anyone's laptop.
+Verify any installed version was built from this exact source:
+
+```bash
+npm audit signatures
+```
+
+See [docs/releasing.md](docs/releasing.md) for the full release process
+and what the provenance attestation actually proves.
+
+## FAQ
+
+**Can't I just import a bunch of libraries to inflate my skills list?**
+No — a bare import alone rarely tags a skill. Most signatures require
+either a distinctive, unambiguous import specifier (not a generic package
+name shared across ecosystems) or an actual API-call shape from your own
+diffs (`stripe.checkout`, not just `import Stripe`). See
+[docs/signatures.md](docs/signatures.md) for the exact detection rules and
+the discipline behind them. But the honest answer is bigger than detection
+accuracy: this CLI only ever produces the **Attested** tier — the weakest
+one on Redential, explicitly labeled as unverified metadata. Padding your
+skills list gets you a slightly longer list on the weakest tier; it does
+nothing for Proven or Verified, which require live code or a defended
+session. Gaming metadata to look impressive on a tier that's already
+labeled "take this with a grain of salt" isn't much of a prize.
+
+**Can't I replay someone else's git history into a new repo and claim it?**
+You could fabricate commit timestamps in a fresh repo — that's exactly why
+local data is explicitly the *weakest* tier, not the strongest. A replayed
+history still has to survive several partial anchors: signed commits (a
+GPG/SSH signature can't be forged retroactively without the key), a
+behavioral fingerprint (the hour/weekday cadence is compared against your
+own verified public activity as a soft consistency check), and — above
+all — the bundle only ever earns **Attested**, metadata only. Anything
+above that requires an NDA-safe defense: a short recorded session where
+you answer questions generated from your own bundle, live. Faking a git
+history is cheap; defending fabricated experience under questioning, in
+real time, is not. That gap is the actual security boundary, not the
+detection heuristics.
+
+**What exactly leaves my machine?**
+The bundle `scan` printed to your terminal — byte for byte, nothing added
+or enriched afterward. That's not a promise you have to take on faith:
+[`test/privacy/submit-guardrail.test.ts`](test/privacy/submit-guardrail.test.ts)
+asserts the literal string sent over HTTP by `submit` is `===` the string
+`scan` printed, not a re-serialization of a parsed object. Every field is
+documented in [docs/schema.md](docs/schema.md), and the schema itself
+(`schema/bundle.v1.json`) sets `additionalProperties: false` everywhere —
+an unlisted field makes the bundle invalid by construction, not just by
+convention.
+
+**Why should I trust a CLI with my employer's code?**
+Because it never touches your employer's code in any form that leaves your
+laptop. It's local-only (`scan` is structurally network-free, not merely
+network-free by default), fully open source under Apache-2.0 so you can
+read every line before running it, and its privacy claims are
+[executable tests](test/privacy/) you run yourself (`npm test`) rather
+than a page of prose. There's no telemetry, no analytics, no background
+process — the only two network calls this CLI ever makes are the `login`
+device flow and the `submit` upload, both requiring your explicit action.
+And every published release carries a Sigstore-signed provenance
+attestation you can verify (`npm audit signatures`), proving it was built
+from this exact repository, not from someone's laptop.
+
+**What does "Attested" actually prove?**
+Honestly, not that much on its own — and that's by design, not an
+oversight. "Attested" means: this person's local git history shows this
+pattern of activity, self-reported and falsifiable, with partial anchors
+(signed commits, behavioral fingerprint, server-side consistency checks)
+but no independent verification of the underlying code. It is never
+labeled or visually mixed with Proven or Verified, which require either
+connecting a readable repository (via the GitHub App) or defending the
+claim live. Think of Attested as "worth a follow-up question," not
+"verified" — the CLI's whole design exists to keep that distinction
+honest instead of letting a metadata bundle borrow credibility it hasn't
+earned. See [docs/principles.md](docs/principles.md) (principle 6,
+"Honest about trust") for the full reasoning.
+
+## Docs
+
+- [docs/principles.md](docs/principles.md) — the six non-negotiable rules
+- [docs/privacy-tests.md](docs/privacy-tests.md) — which test proves which rule
+- [docs/scan.md](docs/scan.md) — full `scan` command reference
+- [docs/login-submit.md](docs/login-submit.md) — `login`, `submit`, `logout`
+- [docs/schema.md](docs/schema.md) — every bundle field, explained
+- [docs/signatures.md](docs/signatures.md) — how skill detection works
+- [docs/releasing.md](docs/releasing.md) — how a release is built and verified
+
+If the repo you're scanning is your own and connectable, `scan` isn't the
+better tool — the [GitHub App](https://redential.com) reads the actual code
+and grants stronger tiers than local metadata ever can.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) — most contributions are a
+one-line addition to a signature map. Bug reports and security issues:
+[SECURITY.md](SECURITY.md).
+
+## License
+
+Apache-2.0

package/dist/build-bundle.js

@@ -0,0 +1,37 @@
+import { runScan, listAuthors } from "./scan.js";
+import { ScanError } from "./errors.js";
+import { promptAuthors, promptConfirmAttestation } from "./prompt.js";
+import { getRemoteUrl } from "./git.js";
+import { publicHostWarning } from "./public-remote.js";
+/**
+ * Shared by `scan` and `submit`: author selection, authorization
+ * confirmation, and the actual scan. `submit` calls this directly instead
+ * of re-deriving the bundle another way, so the bundle it uploads is
+ * produced by the exact same code path `scan` prints (principle 4,
+ * "User-reviewed").
+ */
+export async function buildBundleInteractively(opts) {
+    const warn = opts.warn ?? console.error;
+    const warning = publicHostWarning(getRemoteUrl(opts.repoPath));
+    if (warning)
+        warn(warning);
+    let authors = opts.author;
+    if (authors.length === 0) {
+        const candidates = listAuthors(opts.repoPath);
+        if (candidates.length === 0) {
+            throw new ScanError("This repository has no commits yet — nothing to scan.");
+        }
+        authors = await (opts.promptAuthorsFn ?? promptAuthors)(candidates);
+    }
+    let confirmed = opts.yes;
+    if (!confirmed) {
+        confirmed = await (opts.promptConfirmFn ?? promptConfirmAttestation)();
+    }
+    return runScan({
+        repoPath: opts.repoPath,
+        authors,
+        confirmed,
+        toolVersion: opts.toolVersion,
+        configDir: opts.configDir,
+    });
+}

package/dist/categorize.js

@@ -0,0 +1,25 @@
+// Order matters: first matching rule wins.
+const RULES = [
+    [/(^|\/)(__tests__|tests?|specs?)(\/|$)|\.(test|spec)\.[jt]sx?$/i, "testing"],
+    [/(^|\/)(claude\.md|agents\.md|\.cursor|\.aider|copilot)/i, "ai-workflow"],
+    [
+        /(^|\/)(\.github\/workflows|dockerfile|docker-compose|terraform|k8s|kubernetes|infra)(\/|$|\.)/i,
+        "infra",
+    ],
+    [/(^|\/)(auth|authn|authz|session|oauth|login)(\/|$|[._-])/i, "auth"],
+    [/(^|\/)(pay|payments?|billing|checkout|stripe)(\/|$|[._-])/i, "payments"],
+    [/(^|\/)(migrations?|models?|schema)(\/|$)/i, "data"],
+    [/\.(md|mdx)$|(^|\/)docs(\/|$)/i, "docs"],
+    [
+        /(^|\/)(components?|pages|views|public|styles)(\/|$)|\.(tsx|jsx|css|scss|vue|svelte)$/i,
+        "frontend",
+    ],
+    [/(^|\/)(server|api|controllers?|services)(\/|$)|\.(go|rb|java|rs|py)$/i, "backend"],
+];
+export function categorize(filePath) {
+    for (const [pattern, name] of RULES) {
+        if (pattern.test(filePath))
+            return name;
+    }
+    return "other";
+}

package/dist/churn-exclusions.js

@@ -0,0 +1,51 @@
+// Checked-in artifacts, not authored work — see docs/schema.md's "What is
+// excluded from churn" for the full, versioned list (part of the bundle's
+// measurement contract, not an implementation detail). Without this, a
+// single `npm install`/build commit can dwarf months of actual code in the
+// languages/categories breakdown.
+const LOCKFILE_BASENAMES = new Set(["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb"]);
+const MINIFIED_PATTERN = /\.min\.js$/i;
+// Requires the name to be a full path segment (bounded by "/" or the start,
+// and followed by "/") so it only matches build-output DIRECTORIES, never a
+// substring like "redistribute/" or a same-named leaf file.
+const GENERATED_DIR_PATTERN = /(^|\/)(dist|build|\.next|node_modules)\//i;
+function basename(path) {
+    const idx = path.lastIndexOf("/");
+    return idx === -1 ? path : path.slice(idx + 1);
+}
+/** Lockfile, minified bundle, or build-output path — excluded by name/shape
+ * alone, with no need to look at commit history. */
+export function isExcludedPath(path) {
+    return LOCKFILE_BASENAMES.has(basename(path)) || MINIFIED_PATTERN.test(path) || GENERATED_DIR_PATTERN.test(path);
+}
+// A file whose entire churn history (within the selected author's commits)
+// is a single commit that added at least this many lines is almost always a
+// vendored/generated artifact that happened to get committed — a bundled
+// dependency, a lockfile format not already recognized by name, a one-time
+// codegen dump — rather than authored work. 1000 is comfortably above any
+// plausible hand-written single-file commit.
+export const GENERATED_FILE_MIN_ADDED_LINES = 1000;
+/**
+ * Paths whose only appearance across `commits` is one commit adding at
+ * least `GENERATED_FILE_MIN_ADDED_LINES` lines — "a single commit, no
+ * history before or after it". Operates over whatever commit set the caller
+ * passes in (the selected author's commits, in `scan.ts`), not the whole
+ * repo — this is a per-scan heuristic, not a repo-wide fact.
+ */
+export function heuristicallyGeneratedPaths(commits) {
+    const touchCount = new Map();
+    const soleEntry = new Map();
+    for (const c of commits) {
+        for (const f of c.churn) {
+            touchCount.set(f.path, (touchCount.get(f.path) ?? 0) + 1);
+            soleEntry.set(f.path, f);
+        }
+    }
+    const generated = new Set();
+    for (const [path, count] of touchCount) {
+        if (count === 1 && soleEntry.get(path).added >= GENERATED_FILE_MIN_ADDED_LINES) {
+            generated.add(path);
+        }
+    }
+    return generated;
+}

package/dist/cli.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { Command } from "commander";
+import { ScanError, AuthError, SubmitError, NetworkError } from "./errors.js";
+import { executeScanCommand } from "./scan-command.js";
+import { executeSubmitCommand } from "./submit-command.js";
+import { runLogin } from "./login.js";
+import { runLogout } from "./logout.js";
+function getToolVersion() {
+    const pkgUrl = new URL("../package.json", import.meta.url);
+    const pkg = JSON.parse(readFileSync(pkgUrl, "utf8"));
+    return pkg.version;
+}
+function collect(value, previous) {
+    return previous.concat([value]);
+}
+/** The domain errors every command may throw — never wraps a raw fetch/fs
+ * error, so this catch can safely print `err.message` without risking a
+ * token or bundle leaking through an unsanitized underlying error. */
+function isCliError(err) {
+    return (err instanceof ScanError ||
+        err instanceof AuthError ||
+        err instanceof SubmitError ||
+        err instanceof NetworkError);
+}
+async function run(action) {
+    try {
+        await action();
+    }
+    catch (err) {
+        if (isCliError(err)) {
+            console.error(`Error: ${err.message}`);
+            process.exitCode = 1;
+            return;
+        }
+        throw err;
+    }
+}
+const program = new Command();
+program.name("redential").description("Local, metadata-only proof bundles from git history.");
+program
+    .command("scan")
+    .description("Scan the local git history and print the proof bundle (nothing is uploaded).")
+    .option("--repo <path>", "path to the git repository to scan", ".")
+    .option("--author <email>", "author email that is yours (repeatable); enables non-interactive mode", collect, [])
+    .option("--yes", "confirm 'I am authorized to analyze this repository' non-interactively", false)
+    .option("--json", "force JSON-only output, even on an interactive terminal (default when piped)", false)
+    .action(async (options) => {
+    await run(() => executeScanCommand({
+        repoPath: resolve(options.repo),
+        author: options.author,
+        yes: options.yes,
+        toolVersion: getToolVersion(),
+        isTTY: process.stdout.isTTY === true,
+        json: options.json,
+    }));
+});
+program
+    .command("login")
+    .description("Authenticate via device flow and store a session token locally.")
+    .action(async () => {
+    await run(() => runLogin());
+});
+program
+    .command("logout")
+    .description("Delete the locally stored session token.")
+    .action(async () => {
+    await run(() => runLogout());
+});
+program
+    .command("submit")
+    .description("Scan, review, and upload a proof bundle. Requires a prior `redential login`.")
+    .option("--repo <path>", "path to the git repository to scan", ".")
+    .option("--author <email>", "author email that is yours (repeatable); enables non-interactive mode", collect, [])
+    .option("--yes", "confirm 'I am authorized to analyze this repository' non-interactively", false)
+    .option("--confirm-upload", "confirm the upload itself non-interactively (separate from --yes)", false)
+    .action(async (options) => {
+    await run(() => executeSubmitCommand({
+        repoPath: resolve(options.repo),
+        author: options.author,
+        yes: options.yes,
+        confirmUpload: options.confirmUpload,
+        toolVersion: getToolVersion(),
+    }));
+});
+program.parse();

package/dist/config.js

@@ -0,0 +1,13 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** Same directory for the device salt (salt.ts) and the session token (credentials.ts). */
+export const DEFAULT_CONFIG_DIR = join(homedir(), ".config", "redential");
+/**
+ * Public by design (CLAUDE.md: "solo SITE_URL (pública)"). Overridable via
+ * REDENTIAL_SITE_URL so tests and staging can point the CLI at a local
+ * mock server instead of the real site.
+ */
+export function getSiteUrl() {
+    const raw = process.env.REDENTIAL_SITE_URL ?? "https://www.redential.com";
+    return raw.replace(/\/$/, "");
+}

package/dist/credentials.js

@@ -0,0 +1,26 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { DEFAULT_CONFIG_DIR } from "./config.js";
+function credentialsPath(configDir = DEFAULT_CONFIG_DIR) {
+    return join(configDir, "credentials.json");
+}
+/** Never in the scanned repo's cwd — always the device-local config dir. */
+export function readCredentials(configDir = DEFAULT_CONFIG_DIR) {
+    const path = credentialsPath(configDir);
+    if (!existsSync(path))
+        return null;
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+/** 0600 — same permission pattern as salt.ts's device salt. */
+export function saveCredentials(credentials, configDir = DEFAULT_CONFIG_DIR) {
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(credentialsPath(configDir), JSON.stringify(credentials), { mode: 0o600 });
+}
+/** True if a credentials file existed and was removed; false if there was nothing to do. */
+export function deleteCredentials(configDir = DEFAULT_CONFIG_DIR) {
+    const path = credentialsPath(configDir);
+    if (!existsSync(path))
+        return false;
+    unlinkSync(path);
+    return true;
+}