@cruxy/cli 1.0.2 → 1.0.4

package/dist/checkpoint/gate.d.ts

@@ -1,71 +0,0 @@
-import type { CruxyConfig } from "../config/index.js";
-import { CheckpointService } from "./service.js";
-import type { CheckpointSet } from "./types.js";
-/**
- * Per-root checkpoint gate (C.26 step 3). One run may mutate several declared
- * roots; this owns one {@link CheckpointService} PER touched root (created lazily
- * the first time a mutation is gated for that root) plus the run's
- * {@link CheckpointSet} accumulator, so `cruxy rollback` can restore exactly the
- * roots the run touched — no more, no less.
- *
- * Two invariants live here:
- *   • **exactly-touched** — {@link serviceFor} is the ONLY construction site for a
- *     per-root service, and it is called only when a mutation is actually gated for
- *     that root, so an untouched root's service is never constructed and never
- *     appears in the set.
- *   • **one set per run, shared across subagents** — the parent and every subagent
- *     share this one gate (C.14 wires the child gate over the same object), so a
- *     subagent's writes join the run's single set and are covered by the run's
- *     rollback (⚖︎JC-δ). The set manifest lives under the PRIMARY root (⚖︎#7).
- */
-export type CreateCheckpointService = (root: string, config: CruxyConfig) => CheckpointService;
-export interface CheckpointGateOptions {
-    config: CruxyConfig;
-    /** Absolute path of the primary root — home of the set manifest (⚖︎#7). */
-    primaryRoot: string;
-    /**
-     * Test seam: the sole factory for per-root services. A constructor spy passed
-     * here proves an untouched root's service is never built.
-     */
-    createService?: CreateCheckpointService;
-}
-export declare class CheckpointGate {
-    private readonly config;
-    private readonly primaryRoot;
-    private readonly create;
-    private readonly services;
-    private runId;
-    private summary;
-    private set;
-    constructor(opts: CheckpointGateOptions);
-    /**
-     * Start a new undo unit for the WHOLE run (every root + the set). Resets each
-     * existing per-root service's once-per-run latch and clears the set so the next
-     * mutation begins a fresh run. The set is materialized lazily on the first member
-     * (so its `createdAt` marks the run's first mutation, and a no-mutation run
-     * writes no manifest).
-     *
-     * `runId` may be supplied to key the set manifest by a caller-chosen id (C.28: a
-     * background job passes its OWN id, so `cruxy rollback <jobId>` maps straight to
-     * that job's set and reverts exactly the job — pre- AND post-pause mutations,
-     * because a job calls this ONCE at start and never again on resume). Omitted → a
-     * fresh generated `run-…` id, unchanged from C.26.
-     */
-    beginRun(summary: string, runId?: string): void;
-    /**
-     * Get-or-create the per-root service. The first time a root is touched this
-     * process, its service is constructed and joined to the current run; an untouched
-     * root's service is never built.
-     */
-    serviceFor(rootName: string, rootAbsPath: string): CheckpointService;
-    /**
-     * Record that `rootName` was checkpointed this run: append its member to the set
-     * and persist the manifest under the primary root. Idempotent — later mutations
-     * to the same root this run are no-ops (the root already has exactly one member).
-     */
-    recordMember(rootName: string, rootAbsPath: string, checkpointId: string): Promise<void>;
-    /** Root names that got a per-root service this process (inspection/tests). */
-    get touchedRoots(): readonly string[];
-    /** The current run's set, or null before its first mutation (inspection/tests). */
-    get currentSet(): CheckpointSet | null;
-}

package/dist/checkpoint/git-store.d.ts

@@ -1,61 +0,0 @@
-import type { CaptureFile, CheckpointStore, FileEntry } from "./types.js";
-/**
- * Git-object-backed checkpoint content store (C.32 primary substrate).
- *
- * How a snapshot works — and exactly why it can never disturb the user's git
- * state. Every git invocation is one of these five, and nothing else:
- *
- *   1. `git rev-parse --absolute-git-dir`          (read-only)
- *   2. `git update-index --add -z --stdin`, with `GIT_INDEX_FILE` pointing at a
- *      **temporary index file in os.tmpdir()**. Git hashes each captured file
- *      into `.git/objects` as loose blobs and stages them *in the temp index*.
- *      The user's `.git/index` is never opened for writing.
- *   3. `git write-tree`, same `GIT_INDEX_FILE` — writes tree objects, returns
- *      the root tree oid.
- *   4. `git ls-files --stage -z`, same `GIT_INDEX_FILE` — reads back
- *      `mode oid stage\tpath` per file for the manifest. The temp index is then
- *      deleted.
- *   5. `git cat-file blob <oid>` on restore/preview                (read-only)
- *
- * No `commit-tree`, no `update-ref`, no `stash`, no branch: **no ref is ever
- * created or moved, and HEAD / the index / the stash are never written.** The
- * blobs and trees are deliberately *dangling* — referenced only by the manifest
- * JSON under `.cruxy/checkpoints/`.
- *
- * Enforced, not assumed: {@link snapshot} fingerprints the user-visible state
- * (raw `.git/HEAD` bytes, a hash of `.git/index`, `git for-each-ref`, and
- * `git stash list`) before and after, and throws CRUXY_E_CHECKPOINT_FAILED
- * naming what moved if anything drifted.
- *
- * Accepted trade-off: dangling objects are subject to `git gc --prune`. The
- * default two-week grace plus retention pruning makes that a non-issue, but a
- * user running `git gc --prune=now` can orphan a manifest — then rollback fails
- * loudly (never restores partial state), and the shadow store remains the
- * fallback substrate for new checkpoints.
- */
-export declare class GitCheckpointStore implements CheckpointStore {
-    private readonly root;
-    readonly kind: "git";
-    constructor(root: string);
-    /** Git blob sha-1: `sha1("blob <len>\0" + content)` — matches `git hash-object`. */
-    hashContent(content: Buffer): string;
-    snapshot(files: CaptureFile[]): Promise<FileEntry[]>;
-    readContent(entry: FileEntry): Promise<Buffer>;
-    /** Dangling objects belong to git's own gc; nothing for us to sweep. */
-    collect(): Promise<void>;
-    /** Parse `git ls-files --stage -z` from the temp index into manifest entries. */
-    private readStagedEntries;
-    /**
-     * Run git with binary-safe stdout (restore must round-trip arbitrary bytes),
-     * optional stdin, and optional extra env. Local to this store on purpose —
-     * `runGitCapture` is text-mode and env-less, and the rest of the CLI should
-     * stay that way.
-     */
-    private git;
-    /**
-     * Everything a user can observe of their git state, byte-for-byte: HEAD file,
-     * index contents, every ref (branches, tags, remotes, stash tip — packed or
-     * loose, via for-each-ref), and the full stash reflog (stash list).
-     */
-    private fingerprint;
-}

package/dist/checkpoint/index.d.ts

@@ -1,10 +0,0 @@
-export * from "./types.js";
-export * from "./capture.js";
-export * from "./git-store.js";
-export * from "./shadow-store.js";
-export * from "./restore.js";
-export * from "./service.js";
-export * from "./set.js";
-export * from "./set-rollback.js";
-export * from "./gate.js";
-export * from "./gate-hook.js";

package/dist/checkpoint/restore.d.ts

@@ -1,23 +0,0 @@
-import type { ActionPreview } from "../tools/types.js";
-import type { Checkpoint, CheckpointStore, RollbackApplied, RollbackPlan } from "./types.js";
-/**
- * Diff the current working tree against a checkpoint by content address.
- * External attribution: a differing path the tracked run never touched is
- * flagged `external` — unless the run executed shell commands, in which case
- * attribution is unknowable and the plan says so instead of guessing.
- */
-export declare function computeRollbackPlan(root: string, checkpoint: Checkpoint, store: CheckpointStore, gitWorkTree: boolean): Promise<RollbackPlan>;
-/**
- * Build the U.2 preview for a plan: patch-style entries (byte-identical with
- * apply_patch previews) plus the external-change and boundary annotations that
- * `renderActionPreview` places *above* the diff.
- */
-export declare function buildRollbackPreview(root: string, plan: RollbackPlan, store: CheckpointStore): Promise<Extract<ActionPreview, {
-    type: "rollback";
-}>>;
-/**
- * Apply a plan: recreate deleted files, revert edited ones (content and mode),
- * then remove run-created files (and any directories that emptied out). Any
- * failure is a loud CRUXY_E_CHECKPOINT_FAILED; re-running rollback resumes.
- */
-export declare function applyRollback(root: string, plan: RollbackPlan, store: CheckpointStore): Promise<RollbackApplied>;

package/dist/checkpoint/service.d.ts

@@ -1,89 +0,0 @@
-import type { CruxyConfig } from "../config/index.js";
-import type { ApprovalDecision } from "../approval/types.js";
-import type { ApproveAction } from "../tools/types.js";
-import type { Checkpoint, CheckpointStore, CheckpointStoreKind, RollbackApplied } from "./types.js";
-/** Is `root` inside a git working tree? (Decides the checkpoint substrate.) */
-export declare function isGitWorkTree(root: string): boolean;
-/**
- * The substrate factory: git-object store inside a repo, shadow store outside.
- * Pass `kind` to pin the substrate (rollback must read a checkpoint back with
- * the store that wrote it, recorded in its manifest).
- */
-export declare function createCheckpointStore(root: string, kind?: CheckpointStoreKind): CheckpointStore;
-export interface CheckpointServiceOptions {
-    root: string;
-    config: CruxyConfig;
-    /** Test seam: pin the content store (disables the git→shadow fallback). */
-    store?: CheckpointStore;
-}
-/** What `rollback()` needs from the caller: the U.3 gate and TTY interactivity. */
-export interface RollbackDeps {
-    requestApproval(action: ApproveAction): Promise<ApprovalDecision>;
-    interactive: boolean;
-}
-export type RollbackResult = 
-/** The working tree already matches the checkpoint — nothing to do. */
-{
-    kind: "noop";
-    checkpoint: Checkpoint;
-}
-/** The user saw the preview and declined; nothing was applied. */
- | {
-    kind: "rejected";
-    feedback?: string;
-} | {
-    kind: "applied";
-    checkpoint: Checkpoint;
-    applied: RollbackApplied;
-};
-/**
- * Checkpoint lifecycle (C.32): create once before a run's first mutation,
- * record what the run touches, list/prune, and drive the gated rollback.
- * Manifests are JSON under `.cruxy/checkpoints/` — they survive process exit,
- * so `cruxy rollback` works in a later invocation.
- */
-export declare class CheckpointService {
-    private readonly root;
-    private readonly config;
-    private readonly pinnedStore?;
-    private runSummary;
-    private active;
-    /** In-flight `ensureCheckpoint` construction (C.33). PROMISE-latched, not
-     * value-latched: two concurrent gated writes to this root await the SAME
-     * snapshot instead of each taking one (the once-per-run latch `this.active`
-     * is only set AFTER several awaits, so a boolean/value latch would let a
-     * second caller slip through and double-snapshot). The approval mutex already
-     * serializes gated writes, so this is defense-in-depth — but it makes the
-     * service correct on its own, independent of the caller's discipline. */
-    private pending;
-    constructor(opts: CheckpointServiceOptions);
-    /** Start a new undo unit: reset the once-per-run latch and name the run. */
-    beginRun(summary: string): void;
-    /**
-     * The auto-checkpoint hook, called from the approval seam after every allowed
-     * mutating action and latched to fire once per run — before the first
-     * mutation ever reaches disk. Returns the run's checkpoint, or `null` when
-     * the feature is disabled. Fail-loud: if a checkpoint cannot be written by
-     * either substrate, the run must not mutate without its undo protection.
-     */
-    ensureCheckpoint(): Promise<Checkpoint | null>;
-    private buildCheckpoint;
-    /** Attribute mutated paths to the current run (persisted for later rollback). */
-    recordTouched(absPaths: string[]): Promise<void>;
-    /** The run ran a shell command: per-path attribution is no longer possible. */
-    recordShellMutation(): Promise<void>;
-    /** All checkpoints, newest first. Corrupt manifests are warned about, not fatal. */
-    list(): Promise<Checkpoint[]>;
-    /** One checkpoint by id, or the newest when `id` is omitted. Fail-loud. */
-    read(id?: string): Promise<Checkpoint>;
-    /**
-     * The whole gated restore: preview → U.3 destructive approval → apply.
-     * Non-interactive callers are refused up front — there is no auto-rollback.
-     */
-    rollback(id: string | undefined, deps: RollbackDeps): Promise<RollbackResult>;
-    /** Enforce `checkpoint.retention`: drop oldest manifests, then GC content. */
-    prune(): Promise<void>;
-    private dir;
-    private writeManifest;
-    private readManifestFile;
-}

package/dist/checkpoint/set-rollback.d.ts

@@ -1,51 +0,0 @@
-import type { CruxyConfig } from "../config/index.js";
-import type { ActionPreview } from "../tools/types.js";
-import { CheckpointService } from "./service.js";
-import type { CheckpointSet, CheckpointStore, RollbackPlan, SetRollbackApplied } from "./types.js";
-/**
- * Set-based rollback orchestration (C.26 step 3). Restore every member of a run's
- * {@link CheckpointSet} as one gated operation, with the R3/⚖︎#8 guarantees:
- *   1. **validate-all before any apply** — every member's checkpoint must load and
- *      plan cleanly first ({@link validateSet}); a missing/corrupt one throws
- *      `CRUXY_E_CHECKPOINT_SET_INCOMPLETE` and NOTHING is applied.
- *   2. **one combined preview** grouped by root ({@link buildSetPreview}), each with
- *      its own external-change warnings, behind one U.3 approval (⚖︎JC-ι).
- *   3. **sequential apply, stop on first failure** ({@link applySet}) →
- *      `CRUXY_E_CHECKPOINT_SET_PARTIAL` carrying restored-vs-not; the plan is
- *      recomputed from disk each run, so an idempotent re-run finishes the job.
- */
-export type CreateService = (root: string, config: CruxyConfig) => CheckpointService;
-/** A member whose rollback has been fully validated + planned, ready to apply. */
-export interface ValidatedMember {
-    rootName: string;
-    rootPath: string;
-    checkpointId: string;
-    plan: RollbackPlan;
-    store: CheckpointStore;
-    preview: Extract<ActionPreview, {
-        type: "rollback";
-    }>;
-}
-/**
- * Validate + plan EVERY member up front (R3 gate #1). Loads each root's checkpoint
- * and computes its rollback plan/preview; the first member that cannot be loaded
- * throws `CRUXY_E_CHECKPOINT_SET_INCOMPLETE` — before any filesystem apply — so a
- * partial rollback can never masquerade as success.
- */
-export declare function validateSet(set: CheckpointSet, config: CruxyConfig, createService?: CreateService): Promise<ValidatedMember[]>;
-/**
- * One combined preview grouped by root (⚖︎JC-ι): each root keeps its own file diffs
- * and external-change warnings, so a single U.3 approval covers the whole set.
- */
-export declare function buildSetPreview(set: CheckpointSet, members: ValidatedMember[]): Extract<ActionPreview, {
-    type: "rollback-set";
-}>;
-/**
- * Apply the validated set sequentially, stopping on the first failure (R3/⚖︎#8).
- * On any member's failure this throws `CRUXY_E_CHECKPOINT_SET_PARTIAL` with the
- * restored-vs-not split; re-running (which recomputes each plan from disk) safely
- * finishes the job.
- */
-export declare function applySet(set: CheckpointSet, members: ValidatedMember[]): Promise<SetRollbackApplied>;
-/** Is a validated set a no-op (every member's plan is empty)? */
-export declare function setIsNoop(members: ValidatedMember[]): boolean;

package/dist/checkpoint/set.d.ts

@@ -1,44 +0,0 @@
-import type { CheckpointSet, RollbackApplied, SetRollbackApplied } from "./types.js";
-/**
- * Multi-root rollback sets (C.26). A run that mutates N repos produces one
- * per-root checkpoint plus a {@link CheckpointSet} that ties them together, so
- * `cruxy rollback` restores exactly the touched roots as one gated operation.
- *
- * Two guarantees live here:
- *   • **exactly the touched roots** — the applier iterates ONLY `set.members`, so
- *     an untouched root (absent from the set) is never opened;
- *   • **stop-and-report, never silent partial** (R3) — validate every member up
- *     front (missing/corrupt → `CHECKPOINT_SET_INCOMPLETE`), then apply
- *     sequentially and STOP on the first failure, throwing
- *     `CHECKPOINT_SET_PARTIAL` with the exact restored-vs-not split.
- */
-/** `run-<utc-stamp>-<rand>` — sortable, collision-safe enough for a local CLI. */
-export declare function newRunId(): string;
-/** The set-manifest directory under the PRIMARY root (⚖︎#7). */
-export declare function setDir(primaryRoot: string): string;
-/** Persist a set manifest (atomic temp-then-rename), self-ignoring from git. */
-export declare function writeSet(primaryRoot: string, set: CheckpointSet): Promise<void>;
-/** Read a set manifest, or throw `CHECKPOINT_SET_INCOMPLETE` if missing/corrupt. */
-export declare function readSet(primaryRoot: string, runId: string): Promise<CheckpointSet>;
-/** List all set manifests under the primary root, newest first. */
-export declare function listSets(primaryRoot: string): Promise<CheckpointSet[]>;
-/**
- * One root's rollback, pre-validated (its plan already computed): `restore`
- * actually applies it. The orchestrator builds one per member.
- */
-export interface MemberRollback {
-    rootName: string;
-    restore: () => Promise<RollbackApplied>;
-}
-/**
- * Apply an all-roots rollback: run each member's `restore` in order and STOP on
- * the first failure (R3). On success, returns the restored-vs-per-root summary.
- * On failure, throws `CHECKPOINT_SET_PARTIAL` naming the roots restored (before
- * the failure) and those not restored (the failing one + all not-yet-attempted)
- * — so a partial rollback can never be reported as success, and re-running (which
- * recomputes each root from disk) safely finishes the job.
- *
- * The applier only ever touches roots present in `rollbacks`; an untouched root
- * (never added to the set) is structurally impossible to open here.
- */
-export declare function applySetRollback(runId: string, rollbacks: readonly MemberRollback[]): Promise<SetRollbackApplied>;

package/dist/checkpoint/shadow-store.d.ts

@@ -1,23 +0,0 @@
-import type { CaptureFile, CheckpointStore, FileEntry } from "./types.js";
-/**
- * Shadow-copy checkpoint content store (C.32 fallback substrate): used outside
- * a git repo, or when git plumbing fails mid-snapshot. File contents live in a
- * content-addressed pool at `.cruxy/checkpoints/objects/<sha256>` — identical
- * content across files or checkpoints is stored once, and pruning sweeps
- * objects no longer referenced by any surviving manifest.
- *
- * Writes are temp-file-then-rename so a crash can never leave a torn object; a
- * torn *read* is impossible because an object either exists complete or not at
- * all, and a missing object fails loudly.
- */
-export declare class ShadowCheckpointStore implements CheckpointStore {
-    readonly kind: "shadow";
-    private readonly objectsDir;
-    constructor(root: string);
-    hashContent(content: Buffer): string;
-    snapshot(files: CaptureFile[]): Promise<FileEntry[]>;
-    readContent(entry: FileEntry): Promise<Buffer>;
-    collect(referenced: ReadonlySet<string>): Promise<void>;
-    /** Content-addressed write: skip if present, else temp-then-rename (atomic). */
-    private writeObject;
-}

package/dist/checkpoint/types.d.ts

@@ -1,164 +0,0 @@
-/**
- * Working-tree checkpoints (C.32): a complete snapshot of everything the agent
- * could touch, captured before a run's first mutation, so `cruxy rollback` can
- * undo the entire run — creates, edits, deletes — in one gated operation.
- *
- * Two layers, deliberately separated:
- *   • {@link CheckpointStore} — the *content substrate* (where file bytes
- *     live), swappable like VectorStore: git-object-backed in a repo, a
- *     content-addressed shadow copy otherwise.
- *   • The manifest — uniform JSON under `.cruxy/checkpoints/`, owned by the
- *     service regardless of substrate, so list/prune/rollback never care which
- *     store wrote a checkpoint.
- *
- * Explicit boundary: checkpoints cover WORKING-TREE file state only. They can
- * never undo git commits, pushes, or PRs made during a run (C.15) — that is
- * stated in the rollback preview, not silently implied.
- */
-/** A file selected for capture: project-relative POSIX path + where it is on disk. */
-export interface CaptureFile {
-    path: string;
-    absPath: string;
-}
-/** Which content substrate a checkpoint was written with. */
-export type CheckpointStoreKind = "git" | "shadow";
-/**
- * One captured file in a checkpoint manifest. `oid` is the content address in
- * the store that wrote it: a git blob sha-1 for the git store, a sha-256 for
- * the shadow store. `mode` preserves the executable bit across restore.
- */
-export interface FileEntry {
-    path: string;
-    mode: "100644" | "100755";
-    oid: string;
-}
-/** A persisted checkpoint: identity, provenance, and the full pre-run manifest. */
-export interface Checkpoint {
-    /** Stable id, e.g. `ck-20260703T141530-a4f2`. */
-    id: string;
-    /** ISO-8601 creation time. */
-    createdAt: string;
-    /** One line describing the run this checkpoint protects. */
-    runSummary: string;
-    store: CheckpointStoreKind;
-    /** Every file that existed (and was capturable) before the run's first mutation. */
-    files: FileEntry[];
-    /**
-     * Project-relative paths the tracked run mutated through file tools, recorded
-     * as the run proceeds. At rollback time, a difference on a path NOT in this
-     * list is an *external* change — surfaced loudly in the preview.
-     */
-    touchedPaths: string[];
-    /**
-     * True when the run executed approved shell commands: a shell command can
-     * touch any path, so per-file attribution becomes impossible and the preview
-     * says so instead of guessing.
-     */
-    hasShellMutations: boolean;
-}
-/**
- * The content substrate seam. Implementations persist and retrieve file
- * *contents* only — manifests are the service's job.
- *
- * THE invariant (git store): snapshot/read must never disturb user-visible git
- * state — HEAD, the index, the stash, or any ref. The git store self-checks
- * this at runtime and fails loudly on drift.
- */
-export interface CheckpointStore {
-    readonly kind: CheckpointStoreKind;
-    /** Persist the current contents of `files`; returns the manifest entries. */
-    snapshot(files: CaptureFile[]): Promise<FileEntry[]>;
-    /** The content address `snapshot` would give this buffer (for diffing). */
-    hashContent(content: Buffer): string;
-    /** Read one captured file's bytes back. Throws CRUXY_E_CHECKPOINT_FAILED if gone. */
-    readContent(entry: FileEntry): Promise<Buffer>;
-    /**
-     * Best-effort GC after prune: drop stored content whose oid is no longer
-     * referenced by any surviving manifest. The git store is a no-op (dangling
-     * objects belong to git's own gc); the shadow store sweeps its object pool.
-     */
-    collect(referenced: ReadonlySet<string>): Promise<void>;
-}
-/** What rollback will do to one path. */
-export type RollbackAction = 
-/** The run deleted it — recreate from the checkpoint. */
-"recreate"
-/** The run edited it — revert content (and mode) to the checkpoint. */
- | "revert"
-/** The run created it — delete it. */
- | "delete";
-export interface RollbackEntry {
-    path: string;
-    action: RollbackAction;
-    /**
-     * True when this path changed since the checkpoint but the tracked run never
-     * touched it — concurrent user (or other-tool) work that rollback would
-     * clobber. Always surfaced in the preview; never overwritten silently.
-     */
-    external: boolean;
-    /** Checkpoint-side content to restore (recreate/revert; absent for delete). */
-    entry?: FileEntry;
-}
-/** The computed diff between the current working tree and a checkpoint. */
-export interface RollbackPlan {
-    checkpoint: Checkpoint;
-    /** Sorted by path; empty means the tree already matches the checkpoint. */
-    entries: RollbackEntry[];
-    /** The `external: true` paths, for the preview's warning block. */
-    externalPaths: string[];
-    /** Mirrors {@link Checkpoint.hasShellMutations}: attribution is unknowable. */
-    attributionUnknown: boolean;
-}
-/** Counts of what a successful rollback actually did. */
-export interface RollbackApplied {
-    recreated: number;
-    reverted: number;
-    deleted: number;
-}
-/**
- * One touched root inside a {@link CheckpointSet}: the declared root's name (for
- * attribution in the preview), its absolute path, and the id of the per-root
- * checkpoint that protects it. There is exactly ONE member per root the run
- * mutated — an untouched root has no member and is never opened at rollback.
- */
-export interface CheckpointSetMember {
-    /** Declared workspace-root name (shown in the grouped preview). */
-    rootName: string;
-    /** Absolute path of the root (where its `.cruxy/checkpoints/` live). */
-    rootPath: string;
-    /** The checkpoint id within that root. */
-    checkpointId: string;
-}
-/**
- * A run's rollback unit across N repos (C.26). `cruxy rollback` restores **all
- * members** of a set as one gated operation — exactly the roots the run touched,
- * no more (untouched roots are absent) and no less (a touched root missing its
- * member is a loud `CRUXY_E_CHECKPOINT_SET_INCOMPLETE`, never a silent partial).
- *
- * The set manifest lives under the PRIMARY root's `.cruxy/checkpoints/sets/`, so
- * it travels with the workspace and survives `rm -rf ~/.cruxy`. The member
- * checkpoints themselves live in each root, exactly as in the single-root case.
- */
-export interface CheckpointSet {
-    /** Stable run id, e.g. `run-20260708T031500-a4f2`. */
-    runId: string;
-    /** ISO-8601 creation time (of the set, i.e. the run's first mutation). */
-    createdAt: string;
-    /** One line describing the run this set protects. */
-    runSummary: string;
-    /** One entry per TOUCHED root. */
-    members: CheckpointSetMember[];
-}
-/**
- * The outcome of a successful all-roots rollback: which roots were restored and
- * what each did. On a mid-apply failure this is NOT returned — a
- * `CRUXY_E_CHECKPOINT_SET_PARTIAL` is thrown instead, carrying the restored-vs-not
- * split (R3), so a partial can never read as success.
- */
-export interface SetRollbackApplied {
-    runId: string;
-    /** Root names restored, in apply order. */
-    restored: string[];
-    /** Per-root counts, keyed by root name. */
-    perRoot: Record<string, RollbackApplied>;
-}

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

@@ -1,7 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy checkpoint` (C.32) — inspect the working-tree snapshots that back
- * `cruxy rollback`. Creation is automatic (before a run's first mutation);
- * this command only lists.
- */
-export declare function checkpointCommand(): Command;

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

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

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

@@ -1,8 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy hooks` — inspect and trust hooks + custom slash commands (C.19).
- * `list` shows the resolved catalog (including which project hooks are trusted
- * and any malformed definitions); `trust <path>` records the explicit,
- * reviewed decision to run a project's hooks, bound to their current fingerprint.
- */
-export declare function hooksCommand(): Command;

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

@@ -1,7 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy index` — build or refresh the local codebase search index that backs
- * the `search_codebase` tool. `--status` reports the current state without
- * modifying it; `--force` re-embeds every file regardless of content hashes.
- */
-export declare function indexCommand(): Command;

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

@@ -1,7 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy init` — set up a project (U.6): ensure a key (acquired only if missing),
- * offer to scaffold a project `CRUXY.md`, and offer a first-win demo run. Like
- * `login`, it's interactive-only.
- */
-export declare function initCommand(): Command;

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

@@ -1,8 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy login` — set or replace the API key on demand (U.6). Runs the key step
- * of onboarding (always, even if a key already resolves — this is how you
- * re-key / switch), validates it live, and persists it to the credentials store.
- * Non-interactive invocations fail loud rather than hang.
- */
-export declare function loginCommand(): Command;

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

@@ -1,9 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy mcp` — inspect and control MCP server integration (C.27). `list` shows
- * the configured servers and whether this repo's config is trusted; `trust`
- * records the explicit decision to connect them, bound to the current config
- * fingerprint. Trusting a server runs its code UNSANDBOXED with your privileges,
- * so `trust` restates that plainly before recording.
- */
-export declare function mcpCommand(): Command;

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

@@ -1,8 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy memory` — inspect and control persistent memory (C.29). `list` shows
- * user + project entries and whether project memory is trusted (recalled);
- * `forget`/`clear` remove entries; `trust` records the explicit decision to
- * recall a repo's project memory, bound to its current fingerprint.
- */
-export declare function memoryCommand(): Command;

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

@@ -1,8 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy pr` — turn the current changes into a pull request (C.15). Generates the
- * branch name, conventional commit, and PR title/body from the diff with the
- * model, then runs branch → commit → push → open-PR behind the one U.3 approval.
- * The forge token comes from the environment / `gh`; it's never prompted or stored.
- */
-export declare function prCommand(): Command;

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

@@ -1,18 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy rollback [id]` (C.32/C.26) — restore the working tree to a run's
- * checkpoint(s), undoing everything an agent run changed in one operation.
- * Destructive by definition, so it is preview-first and gated through U.3 at the
- * destructive tier, ungrantable; non-TTY is refused with a coded error before
- * anything is computed. Out of scope, stated in the preview: commits, pushes, and
- * PRs made during the run are not undone.
- *
- * Routing:
- *   • an explicit `<id>` that names a run/JOB set (C.28: a background job's id) →
- *     set-based rollback of exactly that run, restoring every root it touched;
- *   • an explicit `<id>` that is a checkpoint id → single-root rollback (escape
- *     hatch; also the recovery route if the primary root's set index was removed);
- *   • no id, a set manifest exists → set-based rollback of the latest run;
- *   • no id, no set manifest → JC-F fallback to legacy single-root, logged.
- */
-export declare function rollbackCommand(): Command;

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

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