howtofixcli 0.7.13 → 0.7.15

package/dist/checkpoint.js

@@ -1,437 +0,0 @@
-/**
- * Turn checkpoints: a snapshot of the working tree per turn, so a run can be
- * rolled back after the fact, and a picker can jump to any earlier turn.
- *
- * The snapshot lives in a **shadow git repository**, not in the user's repo and
- * not as a stash object. Three reasons, all of which the references share
- * (Claude Code's checkpoints "live beside your git history, not inside it";
- * the same choice is documented upstream):
- *
- *   1. the user's repository gets zero extra refs, objects or history entries;
- *   2. the user's index and HEAD are never touched, so a restore cannot move
- *      HEAD or discard staged work halfway through a turn;
- *   3. it also works when the project is not a git repository at all.
- *
- * The shadow repo is a `GIT_DIR` with `GIT_WORK_TREE` pointed at the project, so
- * `git add -A` / `write-tree` hash the real files without the real repo knowing.
- * `-A` respects `.gitignore`, so `node_modules` and build output are never copied.
- *
- * A checkpoint is a tree sha plus a commit that keeps it reachable under
- * `refs/howtofix/<id>`; without the ref, `git gc` could collect a tree nothing
- * points at. Restore is `read-tree --reset -u` into the worktree plus `clean -fd`
- * — note the missing `-x`: ignored files must survive a rewind.
- */
-import { execFile, execFileSync } from "node:child_process";
-import { promisify } from "node:util";
-import { createHash } from "node:crypto";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { AGENT_DIR } from "./paths.js";
-import { writeFileAtomicSync } from "./fs-atomic.js";
-/** Where every project's shadow repo lives: `~/.howtofix/agent/rewind/<key>`. */
-const REWIND_DIR = join(AGENT_DIR, "rewind");
-/** Ref namespace inside the shadow repo. Also its initial branch name. */
-const REF_PREFIX = "refs/howtofix";
-/** Claude Code's own cap; more than this in one session is a memory, not a history. */
-const MAX_PER_SESSION = 100;
-/**
- * Sessions whose newest checkpoint is older than this are swept from the store.
- *
- * The per-session cap bounds one session, not the store: every `/new` starts a
- * session id, and only a session *swap* drops the old one (`dropSession` in the
- * workbench). Quitting between sessions leaves their checkpoints — and the
- * shadow-repo objects their refs pin — on disk forever, so `~/.howtofix/agent/rewind`
- * only ever grows. Claude Code deletes a session's snapshots in a retention
- * sweep ~30 days after it last saved one (`cleanupPeriodDays`), and the
- * community shadow-git extensions do the same; 30 days is that precedent.
- */
-export const RETENTION_DAYS = 30;
-/**
- * Records the project path a store belongs to, because the directory key is a
- * one-way hash: without it the sweep cannot tell a deleted project from a live
- * one. Stores written before the marker existed age out on their own.
- */
-const PROJECT_MARKER = "project.json";
-/** Per-project metadata file inside the store directory. */
-const META_NAME = "checkpoints.json";
-/** The whole-directory sweep runs once per process, at the first `openStore`. */
-let rewindStoresSwept = false;
-/**
- * True when `root` sits inside a git work tree.
- *
- * Walks up looking for a `.git` entry — a directory in a normal clone, a file in
- * a worktree or submodule — so this costs a couple of `stat` calls instead of a
- * process spawn. A snapshot of a directory that is not a repository is not worth
- * taking: there is no "uncommitted work" to go back to, and the walk still costs
- * seconds on a large tree (measured 1.25s on a 60k-file directory, added to every
- * single prompt).
- */
-function insideWorkTree(root) {
-    let dir = resolve(root);
-    for (;;) {
-        if (existsSync(join(dir, ".git")))
-            return true;
-        const parent = dirname(dir);
-        if (parent === dir)
-            return false;
-        dir = parent;
-    }
-}
-const execFileAsync = promisify(execFile);
-/**
- * `shadowGit` without blocking the event loop.
- *
- * `add -A` and `write-tree` walk the entire worktree, and a plain `execFileSync`
- * froze the UI for the duration: measured at 4.0s on a 180k-file tree, with the
- * screen not even repainting the prompt first, because the call happens in the
- * Enter handler. Async keeps the spinner turning and Ctrl+C alive while git
- * works. Only the two heavy calls use it; the cheap ones stay synchronous.
- */
-async function shadowGitAsync(store, args) {
-    const env = { ...process.env };
-    for (const key of ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_OBJECT_DIRECTORY", "GIT_ALTERNATE_OBJECT_DIRECTORIES", "GIT_NAMESPACE", "GIT_COMMON_DIR"])
-        delete env[key];
-    env.GIT_DIR = store.gitDir;
-    env.GIT_WORK_TREE = store.root;
-    env.GIT_AUTHOR_NAME = env.GIT_COMMITTER_NAME = "howtofix";
-    env.GIT_AUTHOR_EMAIL = env.GIT_COMMITTER_EMAIL = "howtofix@local";
-    const { stdout } = await execFileAsync("git", args, { cwd: store.root, env, encoding: "utf8", maxBuffer: 8 * 1024 * 1024 });
-    return stdout.trim();
-}
-/** Stable per-project key, so two checkouts of one repo do not share snapshots. */
-function projectKey(root) {
-    return createHash("sha1").update(root).digest("hex").slice(0, 16);
-}
-/** Open (creating on first use) the shadow repo for `root`. Idempotent. */
-export function openStore(root) {
-    const absolute = resolve(root).replace(/\/+$/, "") || "/";
-    const projectDir = join(REWIND_DIR, projectKey(absolute));
-    const gitDir = join(projectDir, "git");
-    const store = { root: absolute, gitDir, metaFile: join(projectDir, META_NAME), disabled: false };
-    // The shadow repo is created once per directory and remembered, so the
-    // "is this a repository" walk runs on the first prompt only.
-    if (!existsSync(join(gitDir, "HEAD")) && !insideWorkTree(absolute)) {
-        store.disabled = true;
-        return store;
-    }
-    mkdirSync(projectDir, { recursive: true });
-    if (!existsSync(join(gitDir, "HEAD"))) {
-        mkdirSync(gitDir, { recursive: true });
-        // `git init <path>` treats the argument as a work tree and would create
-        // `<path>/.git`; the repo is initialised through GIT_DIR instead.
-        execFileSync("git", ["init", "--quiet", "--initial-branch=howtofix"], { env: { ...process.env, GIT_DIR: gitDir }, stdio: ["ignore", "ignore", "pipe"] });
-    }
-    adoptExcludes(absolute, gitDir);
-    writeProjectMarker(projectDir, absolute);
-    // First store opened in this process: drop the stores of projects that are
-    // gone or long untouched, never this one — `keep` covers the store whose
-    // project obviously exists (and any `--continue` of an old session in it).
-    if (!rewindStoresSwept) {
-        rewindStoresSwept = true;
-        sweepRewindStores({ keep: projectDir });
-    }
-    return store;
-}
-/**
- * Copy the project's `.git/info/exclude` into the shadow repo, so paths the user
- * deliberately keeps out of git are not snapshotted — and therefore are not
- * deleted by the `clean -fd` half of a restore.
- */
-function adoptExcludes(root, gitDir) {
-    const real = join(root, ".git", "info", "exclude");
-    try {
-        if (!statSync(real).isFile())
-            return;
-        mkdirSync(join(gitDir, "info"), { recursive: true });
-        copyFileSync(real, join(gitDir, "info", "exclude"));
-    }
-    catch {
-        // No real repository, or nothing to adopt.
-    }
-}
-/**
- * Remember which project a store belongs to, so `sweepRewindStores` can tell a
- * deleted project from a live one despite the one-way directory key. A marker
- * that cannot be written only costs that detection — the age check still applies.
- */
-function writeProjectMarker(projectDir, root) {
-    const marker = join(projectDir, PROJECT_MARKER);
-    const payload = `${JSON.stringify({ version: 1, root })}\n`;
-    try {
-        if (readFileSync(marker, "utf8") === payload)
-            return;
-    }
-    catch {
-        // Missing or unreadable marker: fall through and write it.
-    }
-    try {
-        writeFileAtomicSync(marker, payload);
-    }
-    catch {
-        // Left markerless rather than failing the open; the age check still applies.
-    }
-}
-function readMeta(store) {
-    try {
-        const parsed = JSON.parse(readFileSync(store.metaFile, "utf8"));
-        if (parsed?.version === 1 && parsed.sessions)
-            return parsed;
-    }
-    catch {
-        // Missing or unreadable: start over. The shadow repo keeps its objects, and
-        // the next gc collects whatever nothing references any more.
-    }
-    return { version: 1, sessions: {} };
-}
-function writeMeta(store, meta) {
-    mkdirSync(dirname(store.metaFile), { recursive: true });
-    writeFileAtomicSync(store.metaFile, `${JSON.stringify(meta, null, 1)}\n`);
-}
-/** This session's checkpoints, oldest first. */
-export function listCheckpoints(store, sessionId) {
-    if (store.disabled)
-        return [];
-    return [...(readMeta(store).sessions[sessionId] ?? [])].sort((a, b) => a.at - b.at);
-}
-/**
- * Snapshot the worktree and record it as this turn's checkpoint.
- *
- * A tree identical to the previous checkpoint reuses its commit: a read-only
- * turn costs a metadata row and no new object.
- *
- * Async because the two tree-walking calls are the slow part and this runs in the
- * Enter handler; see `shadowGitAsync`.
- */
-export async function createCheckpoint(store, sessionId, prompt) {
-    if (store.disabled)
-        return null;
-    let tree;
-    try {
-        // `-A` stages modifications, deletions and new files; .gitignore still applies.
-        await shadowGitAsync(store, ["add", "-A", "--ignore-errors", "--"]);
-        tree = await shadowGitAsync(store, ["write-tree"]);
-    }
-    catch {
-        // An unreadable or missing worktree is not worth failing a prompt over: the
-        // turn simply has no checkpoint, and the picker will not offer to rewind it.
-        return null;
-    }
-    const existing = listCheckpoints(store, sessionId);
-    const reusable = existing.find((checkpoint) => checkpoint.tree === tree);
-    const at = Date.now();
-    const id = `${at.toString(36)}-${createHash("sha1").update(`${tree}:${at}`).digest("hex").slice(0, 6)}`;
-    let commit = reusable?.commit;
-    if (!commit) {
-        const message = ["howtofix checkpoint", `session ${sessionId}`, `created ${new Date(at).toISOString()}`, `prompt ${prompt.slice(0, 200)}`].join("\n");
-        commit = await shadowGitAsync(store, ["commit-tree", tree, "-m", message]);
-        await shadowGitAsync(store, ["update-ref", `${REF_PREFIX}/${id}`, commit]);
-    }
-    const checkpoint = { id, tree, commit, prompt, at };
-    const meta = readMeta(store);
-    const list = [...(meta.sessions[sessionId] ?? []), checkpoint];
-    // Oldest first out. Their refs are dropped so the objects become collectable.
-    for (const victim of list.slice(0, Math.max(0, list.length - MAX_PER_SESSION))) {
-        try {
-            await shadowGitAsync(store, ["update-ref", "-d", `${REF_PREFIX}/${victim.id}`]);
-        }
-        catch {
-            // A ref that is already gone is the outcome we wanted.
-        }
-    }
-    meta.sessions[sessionId] = list.slice(-MAX_PER_SESSION);
-    writeMeta(store, meta);
-    return checkpoint;
-}
-/**
- * Put the worktree back to a checkpoint.
- *
- * Only the working tree changes. `read-tree --reset -u` restores tracked content
- * to that tree, then `clean -fd` removes files the checkpoint did not have —
- * without `-x`, so ignored files (build output, `node_modules`) are left alone.
- * Newer checkpoints stay in the store, so a rewind is itself undoable by picking
- * a later entry.
- */
-export async function restoreCheckpoint(store, checkpoint) {
-    const removed = [];
-    if (store.disabled)
-        return { ok: false, output: "checkpoints are off: this directory is not a git repository", removed };
-    try {
-        await shadowGitAsync(store, ["read-tree", "--reset", "-u", checkpoint.tree]);
-    }
-    catch (error) {
-        return { ok: false, output: error instanceof Error ? error.message : String(error), removed };
-    }
-    try {
-        const cleaned = await shadowGitAsync(store, ["clean", "-fd"]);
-        for (const line of cleaned.split("\n")) {
-            const match = /^Removing\s+(.+)$/.exec(line.trim());
-            if (match?.[1])
-                removed.push(match[1]);
-        }
-    }
-    catch {
-        // A failed clean leaves files behind; the tree is still restored.
-    }
-    return { ok: true, output: `restored ${checkpoint.prompt || "the checkpoint"}`, removed };
-}
-/** How a checkpoint differs from what is on disk right now, one line per file. */
-export async function checkpointDiff(store, checkpoint) {
-    if (store.disabled)
-        return [];
-    try {
-        // The worktree is hashed into the shadow index first, so the comparison is
-        // between two trees rather than between a tree and a stale index.
-        await shadowGitAsync(store, ["add", "-A", "--ignore-errors", "--"]);
-        const current = await shadowGitAsync(store, ["write-tree"]);
-        if (current === checkpoint.tree)
-            return [];
-        const listed = await shadowGitAsync(store, ["diff-tree", "-r", "--name-status", "--no-commit-id", checkpoint.tree, current]);
-        return listed
-            .split("\n")
-            .filter(Boolean)
-            .map((line) => {
-            const [status, ...rest] = line.split("\t");
-            return `${status?.[0] ?? "?"} ${rest.at(-1) ?? ""}`;
-        });
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Drop sessions whose newest checkpoint is older than the retention window,
- * then let git collect the objects their refs made unreachable.
- *
- * `keep` names the session to leave alone whatever its age: a long-lived
- * session's last snapshot can predate the window, and sweeping the session the
- * user is currently in would offer a rewind menu with nothing behind it.
- *
- * The sweep only ever makes the store smaller: a ref that is already gone, a
- * meta row that is already absent and a failed `git gc` all leave the store
- * correct, just less reclaimed. It is housekeeping, so it never throws.
- */
-export async function sweepExpired(store, options = {}) {
-    const result = { droppedSessions: 0, droppedRefs: 0 };
-    if (store.disabled)
-        return result;
-    const cutoff = (options.now ?? Date.now()) - RETENTION_DAYS * 24 * 60 * 60 * 1000;
-    const meta = readMeta(store);
-    let changed = false;
-    for (const [sessionId, list] of Object.entries(meta.sessions)) {
-        if (sessionId === options.keep)
-            continue;
-        const newest = list.reduce((latest, checkpoint) => Math.max(latest, checkpoint.at), 0);
-        if (newest >= cutoff)
-            continue;
-        delete meta.sessions[sessionId];
-        changed = true;
-        result.droppedSessions += 1;
-        for (const checkpoint of list) {
-            try {
-                await shadowGitAsync(store, ["update-ref", "-d", `${REF_PREFIX}/${checkpoint.id}`]);
-                result.droppedRefs += 1;
-            }
-            catch {
-                // A ref that is already gone is the outcome we wanted.
-            }
-        }
-    }
-    if (!changed)
-        return result;
-    writeMeta(store, meta);
-    // Without this the deleted refs only mark objects collectable; `--prune=now`
-    // reclaims the space in the same pass that promised to reclaim it.
-    try {
-        await shadowGitAsync(store, ["gc", "--quiet", "--prune=now"]);
-    }
-    catch {
-        // Unreachable objects wait for the next sweep that collects anything.
-    }
-    return result;
-}
-/**
- * Drop store directories nothing can need any more: projects that no longer
- * exist, and projects whose store has not been touched for the retention
- * window. The per-project sweep inside `sweepExpired` bounds sessions *within*
- * a store; without this the store of a deleted project — shadow repo, refs and
- * objects included — stays on disk forever, because the directory key is a
- * one-way hash and nothing ever maps it back to a path that is gone.
- *
- * `keep` is the store being opened right now, skipped whatever its age. A
- * store without a `project.json` marker (written before this existed) is aged
- * out on its own signal alone: it cannot be blamed on a missing project.
- *
- * Housekeeping, like `sweepExpired`: failures are recorded and the sweep moves
- * on, and it never throws.
- */
-export function sweepRewindStores(options = {}) {
-    const result = { removedDirs: 0, failed: [] };
-    let entries;
-    try {
-        entries = readdirSync(REWIND_DIR, { withFileTypes: true });
-    }
-    catch {
-        return result; // No store directory yet.
-    }
-    const cutoff = (options.now ?? Date.now()) - RETENTION_DAYS * 24 * 60 * 60 * 1000;
-    const keep = options.keep ? resolve(options.keep) : undefined;
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        const dir = join(REWIND_DIR, entry.name);
-        if (resolve(dir) === keep)
-            continue;
-        try {
-            if (projectGone(dir) || lastTouched(dir) < cutoff) {
-                rmSync(dir, { recursive: true, force: true });
-                result.removedDirs += 1;
-            }
-        }
-        catch {
-            // A directory that cannot be read or removed stays; the next sweep retries it.
-            result.failed.push(entry.name);
-        }
-    }
-    return result;
-}
-/** True when the marker exists, names a project, and that path no longer exists. */
-function projectGone(dir) {
-    try {
-        const parsed = JSON.parse(readFileSync(join(dir, PROJECT_MARKER), "utf8"));
-        if (typeof parsed?.root !== "string" || parsed.root.length === 0)
-            return false;
-        return !existsSync(parsed.root);
-    }
-    catch {
-        return false; // No marker or unreadable: the age check is the only signal.
-    }
-}
-/**
- * Newest sign of use: the meta file every checkpoint and session sweep
- * rewrites, falling back to the directory itself (creation, or any entry
- * added or removed inside it).
- */
-function lastTouched(dir) {
-    try {
-        return statSync(join(dir, META_NAME)).mtimeMs;
-    }
-    catch {
-        return statSync(dir).mtimeMs;
-    }
-}
-/** Forget a session's checkpoints (used when a session is replaced). */
-export async function dropSession(store, sessionId) {
-    if (store.disabled)
-        return;
-    const meta = readMeta(store);
-    for (const checkpoint of meta.sessions[sessionId] ?? []) {
-        try {
-            await shadowGitAsync(store, ["update-ref", "-d", `${REF_PREFIX}/${checkpoint.id}`]);
-        }
-        catch {
-            // Already gone.
-        }
-    }
-    delete meta.sessions[sessionId];
-    writeMeta(store, meta);
-}

package/dist/claims.js

@@ -1,167 +0,0 @@
-/**
- * File claims shared across sessions.
- *
- * Two agents that write the same file produce interleaved edits that neither their
- * parent nor the user can attribute. Worktree isolation removes that when it applies,
- * but it only covers agents inside one call, and only when the project is a git
- * repository — two CLIs open in the same folder, or a run in a plain directory, still
- * race. A claim is the other half: a writer says which paths it is about to touch, and
- * a second writer is refused instead of silently overwriting.
- *
- * File-based on purpose. A claim has to work for processes that never talk to each
- * other — different terminals, different users, a CLI and a script — so it cannot live
- * in one process's memory, and a broker would need something running. One JSON file in
- * the project is the smallest thing that all of them can agree on.
- *
- * The failure mode this guards against is a **lost edit**, so the defaults lean the
- * other way:
- *
- *  - A conflicting claim is refused, not queued. Refusing is recoverable (the caller
- *    retries, or picks another file); an overwrite is not.
- *  - Every failure to read the ledger reads as "unclaimed". A corrupt file must not
- *    block work forever, and the caller it would wrongly block is the one that cannot
- *    see why.
- *  - Claims expire. A process that is killed cannot release what it held, and a stale
- *    claim nobody can clear would lock a path permanently.
- */
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-/** How long a claim is honoured without being refreshed. */
-export const CLAIM_TTL_MS = 30 * 60 * 1000;
-/** Where the ledger lives, relative to the workspace root. */
-export const CLAIMS_FILE = join(".howtofix", "claims.json");
-function ledgerPath(root) {
-    return join(root, CLAIMS_FILE);
-}
-/**
- * Read the ledger, treating anything unreadable as empty.
- *
- * A ledger that cannot be parsed must not stop work: the alternative is a project
- * where a truncated file blocks every writer and the error names no file to fix.
- */
-function read(root, now) {
-    try {
-        const raw = readFileSync(ledgerPath(root), "utf8");
-        const parsed = JSON.parse(raw);
-        const claims = Array.isArray(parsed.claims) ? [...parsed.claims] : [];
-        return claims.filter((c) => typeof c?.path === "string" &&
-            typeof c?.holder === "string" &&
-            typeof c?.at === "number" &&
-            // Expiry is applied on read rather than by a sweeper, so a dead
-            // process needs nothing to clean up after it.
-            now - c.at < CLAIM_TTL_MS);
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Write the ledger through a temporary file.
- *
- * Two processes claiming at the same time is the normal case, not an edge one, and a
- * partial write would be read back as "no claims" by the next caller — the exact
- * silent failure this module exists to prevent.
- */
-function write(root, claims) {
-    const target = ledgerPath(root);
-    mkdirSync(dirname(target), { recursive: true });
-    const tmp = `${target}.${process.pid}.tmp`;
-    writeFileSync(tmp, JSON.stringify({ version: 1, claims: [...claims] }, null, 2));
-    renameSync(tmp, target);
-}
-/** Resolve a caller-supplied path against the workspace root. */
-function absolute(root, path) {
-    return isAbsolute(path) ? resolve(path) : resolve(root, path);
-}
-/**
- * True when the two paths overlap.
- *
- * A directory claim covers everything beneath it, and a claim on a file covers that
- * file. The check is on path segments, not string prefixes: `src/auth` must not claim
- * `src/authentication`, which a `startsWith` would.
- */
-export function overlaps(a, b) {
-    if (a === b)
-        return true;
-    const withSep = (p) => (p.endsWith(sep) ? p : p + sep);
-    return a.startsWith(withSep(b)) || b.startsWith(withSep(a));
-}
-/** Claims that are live now, expired ones already dropped. */
-export function activeClaims(root, now = Date.now()) {
-    return read(root, now);
-}
-/**
- * Claim paths for one holder, refusing the ones already held by someone else.
- *
- * Returns what was granted and what was refused rather than throwing: a caller that
- * is refused one file out of three should still learn which two it can work on, and a
- * thrown error loses that.
- *
- * Claiming a path this holder already holds is a renewal, not a conflict — a long run
- * that re-states its files must not be refused by its own claim.
- */
-export function claim(request) {
-    const now = request.now ?? Date.now();
-    const existing = read(request.root, now);
-    const granted = [];
-    const conflicts = [];
-    const added = [];
-    for (const raw of request.paths) {
-        if (!raw.trim())
-            continue;
-        const path = absolute(request.root, raw.trim());
-        const rival = existing.find((c) => c.holder !== request.holder && overlaps(c.path, path));
-        if (rival) {
-            conflicts.push({
-                path: display(request.root, path),
-                by: rival.holder,
-                reason: rival.reason || "no reason given",
-            });
-            continue;
-        }
-        granted.push(display(request.root, path));
-        added.push({ path, holder: request.holder, reason: request.reason, at: now });
-    }
-    if (added.length > 0) {
-        // A renewal replaces the holder's earlier entry for the same path so the file
-        // does not grow without bound across a long session.
-        const kept = existing.filter((c) => c.holder !== request.holder || !added.some((a) => a.path === c.path));
-        write(request.root, [...kept, ...added]);
-    }
-    return { granted, conflicts };
-}
-/** Release a holder's claims, optionally only a subset. */
-export function release(root, holder, paths) {
-    const now = Date.now();
-    const existing = read(root, now);
-    const wanted = paths?.length ? paths.map((p) => absolute(root, p.trim())).filter(Boolean) : undefined;
-    const kept = [];
-    const freed = [];
-    for (const c of existing) {
-        const mine = c.holder === holder;
-        const selected = wanted === undefined || wanted.some((p) => overlaps(c.path, p));
-        if (mine && selected)
-            freed.push(display(root, c.path));
-        else
-            kept.push(c);
-    }
-    write(root, kept);
-    return freed;
-}
-/** The holder's live claims, for a UI line or a "what am I holding" answer. */
-export function heldBy(root, holder, now = Date.now()) {
-    return read(root, now).filter((c) => c.holder === holder);
-}
-/** Every live claim, for the who-is-doing-what view. */
-export function allClaims(root, now = Date.now()) {
-    return read(root, now);
-}
-/** Show a path the way the caller wrote it, so a refusal names a recognisable file. */
-function display(root, path) {
-    const rel = relative(root, path);
-    return rel && !rel.startsWith("..") ? rel : path;
-}
-/** True when a project root is usable — the ledger is only written under an existing directory. */
-export function canClaimAt(root) {
-    return existsSync(root);
-}