@bli-cockpit/cli 0.2.0 → 0.2.1

package/README.md

@@ -19,7 +19,13 @@ Ticket: general ambient
 What's your @buildlaunchiterate.ca email? (press enter to skip): ian@buildlaunchiterate.ca
 Signing in as ian@buildlaunchiterate.ca.
 Code sent; valid 1h, resend in 60s by rerunning this command.
-Enter the 6-digit code: 482913
+Email code needed:
+  Check your latest Cockpit email for a 6- to 10-digit code.
+What you can do:
+  1) Paste the code here.
+  2) No code yet: wait for the resend window, then rerun this command.
+  3) Can't use email: rerun with --no-auth for manual approval.
+Code: 482913
 Signed in as ian@buildlaunchiterate.ca.
 2/5 Device paired.
 PASS: Cockpit collector is ready for harvest.
@@ -76,6 +82,7 @@ cockpit onboard --no-auth
 
 - `--email` skips the email prompt.
 - `--workspace` pins one collection root; repeat it for multiple unrelated roots.
+- `--allow-home-root` deliberately collects your whole home folder. Use it only on a company machine where that is intended.
 - `--device-name` changes only the human label shown in Cockpit.
 - `--dashboard-url` is for staging/custom dashboards only. Production is the default.
 - `--no-auth` forces the old manual approval queue.

package/dist/commands/local-args.js

@@ -61,6 +61,7 @@ function parseOnboardLikeArgs(args, command) {
             "--timeout-ms",
             "--max-depth",
             "--max-repos",
+            "--allow-home-root",
         ],
         valueFlags: [
             "--home",
@@ -94,6 +95,7 @@ function parseOnboardLikeArgs(args, command) {
         timeoutMs: optionalPositiveInteger(values.flags.get("--timeout-ms"), "--timeout-ms"),
         maxDepth: optionalPositiveInteger(values.flags.get("--max-depth"), "--max-depth"),
         maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),
+        allowHomeRoot: values.booleans.has("--allow-home-root"),
     };
 }
 function parseOnboardArgs(args) {
@@ -115,6 +117,7 @@ function parseInstallArgs(args) {
             "--dashboard-url",
             "--supabase-url",
             "--json",
+            "--allow-home-root",
         ],
         valueFlags: [
             "--home",
@@ -132,6 +135,7 @@ function parseInstallArgs(args) {
         dashboardUrl: normalizeUrl(values.flags.get("--dashboard-url") ?? DEFAULT_DASHBOARD_URL),
         supabaseUrl: optionalNonEmpty(values.flags.get("--supabase-url")),
         json: values.booleans.has("--json"),
+        allowHomeRoot: values.booleans.has("--allow-home-root"),
     };
 }
 function parseReleaseArgs(args) {

package/dist/commands/local.js

@@ -8,14 +8,15 @@ import { runBackfillCommand } from "./backfill.js";
 import { inspectBackfillLock } from "../backfill-lock.js";
 import { parseLocalArgs, normalizeUrl } from "./local-args.js";
 import { autostartStatus, installAutostartAgent, uninstallAutostartAgent, } from "../autostart.js";
-import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, inspectLocalCollectorStatus, installLocalCollector, logoutLocalCollector, pairLocalCollector, readLocalCollectorConfig, readLocalCollectorSessionFile, readLocalSessionReference, startLocalWorkContext, } from "../local-state.js";
+import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, inspectLocalCollectorStatus, installLocalCollector, logoutLocalCollector, pairLocalCollector, LOCAL_COLLECTOR_VERSION, readLocalCollectorConfig, readLocalCollectorSessionFile, readLocalSessionReference, startLocalWorkContext, } from "../local-state.js";
 import { CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT, CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES, defaultCodexSessionDirs, scanAndAttributeCodexSessions, } from "../adapters/codex-attribution.js";
 import { scanAndAttributeClaudeSessions } from "../adapters/claude-attribution.js";
 import { backfillCompletionMarkerPath, readBackfillCursor, } from "../cursors/backfill-cursor.js";
 import { acquireSyncLock } from "../sync-lock.js";
 import { discoverGitWorktrees } from "../repo-identity.js";
 import { runAttributedWorktreeSync, } from "./session-sync.js";
-import { COLLECTION_ROOT_REQUIRED, resolveOnboardingRoots, } from "../onboarding-roots.js";
+import { COLLECTION_ROOT_REQUIRED, missingCollectionRootMessage, normalizeRootsDetailed, resolveOnboardingRoots, rootRejectionExplanation, } from "../onboarding-roots.js";
+import { rawEvidenceGcSummary, runRawEvidenceLocalGc, } from "../raw-evidence-gc.js";
 export const rootCommandNames = new Set([
     "onboard",
     "update",
@@ -90,10 +91,10 @@ export function localCommandHelp(command) {
     if (command)
         return localSubcommandHelp(command);
     return [
-        "  cockpit onboard [--ticket <id>] [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--branch <name>] [--no-auth] [--max-depth <n>] [--max-repos <n>] [--json]",
-        "  cockpit update [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--no-auth] [--json]",
+        "  cockpit onboard [--ticket <id>] [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--allow-home-root] [--branch <name>] [--no-auth] [--max-depth <n>] [--max-repos <n>] [--json]",
+        "  cockpit update [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--allow-home-root] [--no-auth] [--json]",
         "  cockpit upgrade [same flags as update]",
-        "  cockpit install [--dashboard-url <url>] [--workspace <path>] [--json]",
+        "  cockpit install [--dashboard-url <url>] [--workspace <path>] [--allow-home-root] [--json]",
         "  cockpit login [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--no-auth] [--json]",
         "  cockpit pair [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--no-auth] [--json]",
         "  cockpit logout",
@@ -115,7 +116,7 @@ function localSubcommandHelp(command) {
         [
             "onboard",
             [
-                "Usage: cockpit onboard [--ticket <id>] [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--branch <name>] [--no-auth] [--json]",
+                "Usage: cockpit onboard [--ticket <id>] [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--allow-home-root] [--branch <name>] [--no-auth] [--json]",
                 "",
                 "Installs, pairs, starts work context(s), syncs once, and prints readiness proof.",
                 "If --workspace is a parent folder, scans child git repos/worktrees and rolls them up by repo.",
@@ -129,7 +130,7 @@ function localSubcommandHelp(command) {
         [
             "install",
             [
-                "Usage: cockpit install [--dashboard-url <url>] [--workspace <path>] [--json]",
+                "Usage: cockpit install [--dashboard-url <url>] [--workspace <path>] [--allow-home-root] [--json]",
                 "",
                 "Writes local collector config. Pair with `cockpit login`, then run `cockpit start` when work begins.",
                 "`--repo <path>` remains supported as a backward-compatible alias.",
@@ -139,7 +140,7 @@ function localSubcommandHelp(command) {
         [
             "update",
             [
-                "Usage: cockpit update [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--no-auth] [--json]",
+                "Usage: cockpit update [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--allow-home-root] [--no-auth] [--json]",
                 "",
                 "Updates the global public CLI from npm, then reruns `cockpit onboard`",
                 "with the same setup flags so pairing, saved roots, agent rules,",
@@ -294,19 +295,69 @@ function isLocalHelpRequest(argv) {
     return argv.length === 2 && (argv[1] === "--help" || argv[1] === "-h");
 }
 async function runInstall(command, io) {
-    const result = await installLocalCollector(command);
+    const installEvents = [];
+    const finish = async (code) => {
+        await reportInstallEventsBestEffort({
+            homeDir: command.homeDir,
+            dashboardUrl: command.dashboardUrl,
+            command: "install",
+            events: installEvents,
+            json: command.json,
+            io,
+        });
+        return code;
+    };
+    const resolved = resolveInstallCommandRoots(command);
+    if (resolved.homeRootOptIn) {
+        addInstallEvent(installEvents, "home_root_optin", "ok");
+    }
+    const result = await installLocalCollector(resolved.command);
+    addInstallEvent(installEvents, "install", "ok");
     if (command.json) {
         writeLine(io.stdout, JSON.stringify(result, null, 2));
-        return 0;
+        return finish(0);
     }
     writeLine(io.stdout, "Cockpit local collector installed.");
     writeLine(io.stdout, `Config: ${result.paths.config_file}`);
     writeLine(io.stdout, `Session: ${result.paths.session_file}`);
     writeLine(io.stdout, "Auth: missing; upload stays local-only until pairing/login.");
     writeLine(io.stdout, "Next: run `cockpit login`, then `cockpit start` inside the repo; add `--ticket <id>` only when ticket work begins.");
-    return 0;
+    return finish(0);
+}
+function resolveInstallCommandRoots(command) {
+    const detailed = normalizeRootsDetailed([command.repoRoot ?? process.cwd()], {
+        homeDir: command.homeDir,
+        allowHomeRoot: command.allowHomeRoot,
+    });
+    if (detailed.roots.length > 0) {
+        const root = detailed.roots[0];
+        return {
+            command: {
+                ...command,
+                repoRoot: root,
+            },
+            homeRootOptIn: Boolean(command.allowHomeRoot) &&
+                path.resolve(root) === path.resolve(command.homeDir ?? os.homedir()),
+        };
+    }
+    if (detailed.rejected.length > 0) {
+        throw new Error(`${COLLECTION_ROOT_REQUIRED}: ${rootRejectionExplanation(detailed.rejected[0], command)}`);
+    }
+    throw new Error(`${COLLECTION_ROOT_REQUIRED}: ${missingCollectionRootMessage(command)}`);
 }
 async function runUpdate(command, io) {
+    const installEvents = [];
+    const finish = async (code) => {
+        await reportInstallEventsBestEffort({
+            homeDir: command.homeDir,
+            dashboardUrl: command.dashboardUrl,
+            command: "update",
+            events: installEvents,
+            json: command.json,
+            io,
+        });
+        return code;
+    };
     const exec = io.exec ?? defaultExec();
     const installArgs = [
         "install",
@@ -320,6 +371,9 @@ async function runUpdate(command, io) {
     const install = await exec("npm", installArgs);
     writeExecOutput(io, install, { stdout: !command.json, stderr: true });
     if (install.code !== 0) {
+        addInstallEvent(installEvents, "npm_install", "fail", isNpmEaccesFailure(install.stderr)
+            ? "npm_install_eacces"
+            : "npm_install_failed");
         if (command.json) {
             writeLine(io.stdout, JSON.stringify({
                 status: "blocked",
@@ -335,8 +389,9 @@ async function runUpdate(command, io) {
                 writeLine(io.stderr, "Do not use `sudo npm i -g`; it makes the ownership problem come back.");
             }
         }
-        return install.code || 1;
+        return finish(install.code || 1);
     }
+    addInstallEvent(installEvents, "npm_install", "ok");
     if (!command.json) {
         writeLine(io.stdout, "Cockpit CLI updated. Rechecking onboarding...");
     }
@@ -345,7 +400,8 @@ async function runUpdate(command, io) {
         ...updateOnboardArgs(command),
     ]);
     writeExecOutput(io, onboard, { stdout: true, stderr: true });
-    return onboard.code;
+    addInstallEvent(installEvents, "onboard_rerun", onboard.code === 0 ? "ok" : "fail", onboard.code === 0 ? undefined : updateOnboardFailureCode(onboard));
+    return finish(onboard.code);
 }
 async function runRelease(command, io) {
     const releaseRoot = await findPublicReleaseRoot(process.cwd());
@@ -459,6 +515,8 @@ function updateOnboardArgs(command) {
         args.push("--max-depth", String(command.maxDepth));
     if (command.maxRepos !== undefined)
         args.push("--max-repos", String(command.maxRepos));
+    if (command.allowHomeRoot)
+        args.push("--allow-home-root");
     if (command.json)
         args.push("--json");
     return args;
@@ -466,6 +524,17 @@ function updateOnboardArgs(command) {
 function isNpmEaccesFailure(stderr) {
     return /EACCES|permission denied/i.test(stderr);
 }
+function updateOnboardFailureCode(result) {
+    const output = `${result.stdout}\n${result.stderr}`;
+    if (output.includes(COLLECTION_ROOT_REQUIRED))
+        return COLLECTION_ROOT_REQUIRED;
+    if (/pairing|approval|device_pairing/i.test(output))
+        return "pairing_timeout";
+    if (/sync_blocked|spooled|upload failed|network_or_ingest/i.test(output)) {
+        return "sync_blocked";
+    }
+    return "onboard_rerun_failed";
+}
 function updateCollectionRoots(command) {
     const roots = command.collectionRoots?.length
         ? command.collectionRoots
@@ -482,6 +551,108 @@ function updateCollectionRoots(command) {
     }
     return deduped;
 }
+function addInstallEvent(events, step, status, errorCode) {
+    events.push({
+        step,
+        status,
+        ...(errorCode ? { error_code: sanitizeInstallErrorCode(errorCode) } : {}),
+    });
+}
+function addOnboardFailureEvent(events, blocker) {
+    const step = onboardFailureStep(blocker, events);
+    const existing = events.find((event) => event.step === step && event.status === "fail");
+    if (existing)
+        return;
+    addInstallEvent(events, step, "fail", blocker);
+}
+function addAutostartInstallEvent(events, result) {
+    if (!result) {
+        addInstallEvent(events, "autostart", "skipped", "runner_unavailable");
+        return;
+    }
+    if (result.status === "unsupported") {
+        addInstallEvent(events, "autostart", "skipped", "unsupported");
+        return;
+    }
+    addInstallEvent(events, "autostart", result.loaded === false ? "fail" : "ok", result.loaded === false ? "autostart_load_failed" : undefined);
+}
+function onboardFailureStep(blocker, events) {
+    if (blocker === COLLECTION_ROOT_REQUIRED)
+        return "install";
+    if (blocker === "device_pairing")
+        return "pair";
+    if (blocker === "work_context" || blocker === "ticket_binding" || blocker === "ticket") {
+        return "work_context";
+    }
+    if (blocker === "network_or_ingest")
+        return "sync";
+    if (blocker === "install")
+        return "install";
+    const lastIncomplete = ["install", "auth", "pair", "work_context", "sync"].find((step) => !events.some((event) => event.step === step));
+    return lastIncomplete ?? "sync";
+}
+function sanitizeInstallErrorCode(value) {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_]+/gu, "_")
+        .replace(/^_+|_+$/gu, "")
+        .slice(0, 120);
+    return normalized || "unknown";
+}
+async function reportInstallEventsBestEffort(options) {
+    if (options.events.length === 0)
+        return;
+    const paths = getCollectorRuntimePaths(options.homeDir);
+    const session = await readLocalCollectorSessionFile(paths).catch(() => null);
+    if (!session ||
+        session.session_state !== "valid" ||
+        typeof session.device_token !== "string" ||
+        !session.device_token) {
+        return;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5_000);
+    try {
+        const response = await options.io.fetch(`${options.dashboardUrl}/api/ambient/install-events`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${session.device_token}`,
+            },
+            body: JSON.stringify({
+                cli_version: LOCAL_COLLECTOR_VERSION,
+                command: options.command,
+                os_platform: os.platform(),
+                events: options.events.slice(0, 40),
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`http_${response.status}`);
+        }
+    }
+    catch (error) {
+        if (options.json) {
+            writeLine(options.io.stderr, `Install event telemetry skipped: ${classifyInstallTelemetryError(error)}`);
+        }
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function classifyInstallTelemetryError(error) {
+    if (error instanceof Error && error.name === "AbortError") {
+        return "timeout";
+    }
+    const message = errorMessage(error);
+    const status = message.match(/http_(\d{3})/i)?.[1];
+    if (status)
+        return `http_${status}`;
+    if (/fetch|network|ENOTFOUND|ECONNREFUSED/i.test(message))
+        return "network";
+    return "failed";
+}
 function writeExecOutput(io, result, options) {
     if (options.stdout)
         writeRaw(io.stdout, result.stdout);
@@ -537,12 +708,29 @@ function onboardingRootPrompt(io) {
     return {
         confirm: async (message) => yesByDefault(await readLine(io, message)),
         input: (message) => readLine(io, message),
+        message: (message) => writeLine(io.stdout, message),
     };
 }
 function yesByDefault(raw) {
     const answer = raw.trim().split(/\s+/u)[0]?.toLowerCase() ?? "";
     return answer !== "n" && answer !== "no";
 }
+const OTP_CODE_PROMPT = [
+    "Email code needed:",
+    "  Check your latest Cockpit email for a 6- to 10-digit code.",
+    "What you can do:",
+    "  1) Paste the code here.",
+    "  2) No code yet: wait for the resend window, then rerun this command.",
+    "  3) Can't use email: rerun with --no-auth for manual approval.",
+    "Code: ",
+].join("\n");
+const OTP_INVALID_MESSAGE = [
+    "Email code was not accepted:",
+    "  Cockpit expects digits only, length 6 to 10.",
+    "What you can do:",
+    "  1) Rerun and paste the latest email code.",
+    "  2) Use manual approval: cockpit onboard --no-auth --email <you@buildlaunchiterate.ca>",
+].join("\n");
 async function resolveOnboardEmail(command, roots, config, io) {
     if (command.claimedOwnerEmail)
         return command.claimedOwnerEmail;
@@ -576,11 +764,17 @@ async function resolveInteractiveLoginEmail(command, io) {
     return promptOnboardEmail(io);
 }
 async function requestPairingAccessToken(input, io) {
+    return (await requestPairingAccessTokenDetailed(input, io)).accessToken;
+}
+async function requestPairingAccessTokenDetailed(input, io) {
     if (!input.email ||
         input.noAuth ||
         input.json ||
         !isInteractiveStdin(io)) {
-        return undefined;
+        return {
+            status: "skipped",
+            errorCode: authSkippedReason(input, io),
+        };
     }
     try {
         const fetchImpl = io.fetch;
@@ -590,23 +784,43 @@ async function requestPairingAccessToken(input, io) {
             ? start.resend_after_seconds
             : 60;
         writeLine(io.stdout, `Code sent; valid 1h, resend in ${resendAfter}s by rerunning this command.`);
-        const code = (await readLine(io, "Enter the 6-digit code: ")).trim();
-        if (!/^\d{6}$/.test(code)) {
-            throw new Error("OTP code must be 6 digits.");
+        const code = (await readLine(io, OTP_CODE_PROMPT)).trim();
+        if (!/^\d{6,10}$/.test(code)) {
+            throw new Error(OTP_INVALID_MESSAGE);
         }
         const verified = await postOtpVerify(fetchImpl, input.dashboardUrl, input.email, code);
         if (typeof verified.access_token !== "string" || !verified.access_token) {
             throw new Error("OTP verified but dashboard returned no access token.");
         }
         writeLine(io.stdout, `Signed in as ${input.email}.`);
-        return verified.access_token;
+        return { status: "ok", accessToken: verified.access_token };
     }
     catch (error) {
         writeLine(io.stderr, `Auth step skipped: ${errorMessage(error)}`);
         writeLine(io.stderr, "Continuing with manual dashboard approval.");
-        return undefined;
+        return { status: "fail", errorCode: classifyAuthError(error) };
     }
 }
+function authSkippedReason(input, io) {
+    if (!input.email)
+        return "email_missing";
+    if (input.noAuth)
+        return "no_auth";
+    if (input.json)
+        return "json_mode";
+    if (!isInteractiveStdin(io))
+        return "non_interactive";
+    return "auth_skipped";
+}
+function classifyAuthError(error) {
+    const message = errorMessage(error);
+    if (/\b(otp|code|digit|invalid)\b/i.test(message))
+        return "otp_invalid";
+    if (/fetch|network|ENOTFOUND|ECONNREFUSED|HTTP/i.test(message)) {
+        return "network_or_auth";
+    }
+    return "auth_failed";
+}
 async function pairLocalCollectorWithAuthFallback(options, io) {
     try {
         return await pairLocalCollector(options);
@@ -790,6 +1004,18 @@ function backgroundSyncLine(result) {
     return result.status;
 }
 async function runOnboard(command, io) {
+    const installEvents = [];
+    const finish = async (code) => {
+        await reportInstallEventsBestEffort({
+            homeDir: command.homeDir,
+            dashboardUrl: command.dashboardUrl,
+            command: "onboard",
+            events: installEvents,
+            json: command.json,
+            io,
+        });
+        return code;
+    };
     let install = null;
     let pair = null;
     let sync = null;
@@ -813,6 +1039,7 @@ async function runOnboard(command, io) {
             explicitRoots: command.collectionRoots ?? (command.repoRoot ? [command.repoRoot] : []),
             config: existingConfig,
             interactive,
+            allowHomeRoot: command.allowHomeRoot,
             prompt: interactive ? onboardingRootPrompt(io) : undefined,
         });
         const collectionRoots = rootsResult.roots;
@@ -831,6 +1058,9 @@ async function runOnboard(command, io) {
         if (!command.json) {
             writeLine(io.stdout, `Collecting from: ${collectionRoots.join(", ")}`);
         }
+        if (rootsResult.homeRootOptIn) {
+            addInstallEvent(installEvents, "home_root_optin", "ok");
+        }
         const claimedOwnerEmail = await resolveOnboardEmail(resolvedCommand, collectionRoots, existingConfig, io);
         install = await installLocalCollector({
             homeDir: command.homeDir,
@@ -840,6 +1070,7 @@ async function runOnboard(command, io) {
             dashboardUrl: command.dashboardUrl,
             deviceName: command.deviceName,
         });
+        addInstallEvent(installEvents, "install", "ok");
         if (!command.json) {
             writeLine(io.stdout, "1/5 Installed local collector.");
             writeLine(io.stdout, `Config: ${install.paths.config_file}`);
@@ -852,6 +1083,8 @@ async function runOnboard(command, io) {
         const installedSession = await readOnboardSessionReuseCandidate(command.homeDir);
         const canReuseInstalledSession = canReuseOnboardSession(installedSession, claimedOwnerEmail, command.dashboardUrl);
         if (installedStatus.session_state === "valid" && canReuseInstalledSession) {
+            addInstallEvent(installEvents, "auth", "skipped", "existing_session");
+            addInstallEvent(installEvents, "pair", "skipped", "existing_session");
             if (!command.json) {
                 writeLine(io.stdout, "2/5 Existing valid device session found; pairing skipped.");
             }
@@ -863,12 +1096,13 @@ async function runOnboard(command, io) {
                     writeLine(io.stdout, "2/5 Existing valid device session does not match requested owner or dashboard; pairing again.");
                 }
             }
-            const pairingAccessToken = await requestPairingAccessToken({
+            const authResult = await requestPairingAccessTokenDetailed({
                 dashboardUrl: command.dashboardUrl,
                 email: claimedOwnerEmail,
                 noAuth: command.noAuth,
                 json: command.json,
             }, io);
+            addInstallEvent(installEvents, "auth", authResult.status, authResult.errorCode);
             pair = await pairLocalCollectorWithAuthFallback({
                 homeDir: command.homeDir,
                 dashboardUrl: command.dashboardUrl,
@@ -876,12 +1110,13 @@ async function runOnboard(command, io) {
                 deviceName: command.deviceName,
                 pollIntervalMs: command.pollIntervalMs,
                 timeoutMs: command.timeoutMs,
-                pairingAccessToken,
+                pairingAccessToken: authResult.accessToken,
                 fetch: io.fetch,
                 onPairStarted: command.json
                     ? undefined
                     : (request) => writePairingInstructions(io, request),
             }, io);
+            addInstallEvent(installEvents, "pair", "ok");
             if (!command.json) {
                 writeLine(io.stdout, "2/5 Device paired.");
                 writeLine(io.stdout, `User: ${pair.session.email ?? pair.session.auth_subject_id}`);
@@ -891,9 +1126,13 @@ async function runOnboard(command, io) {
         const worktrees = await discoverCommandWorktrees(collectionRoots, { maxDepth: command.maxDepth, maxRepos: command.maxRepos }, io);
         if (worktrees.length > 1) {
             const multi = await runMultiRepoOnboard(resolvedCommand, io, worktrees);
+            addInstallEvent(installEvents, "work_context", "ok");
+            addInstallEvent(installEvents, "sync", multi.ok ? "ok" : "fail", multi.ok ? undefined : "sync_blocked");
             if (multi.ok) {
                 agentRules = await refreshOnboardAgentRules(resolvedCommand, collectionRoots, io);
+                addInstallEvent(installEvents, "agent_rules", "ok");
                 autostart = await refreshOnboardAutostart(resolvedCommand, collectionRoots, io);
+                addAutostartInstallEvent(installEvents, autostart);
             }
             if (command.json) {
                 writeLine(io.stdout, JSON.stringify({
@@ -919,7 +1158,7 @@ async function runOnboard(command, io) {
                     backfillHint,
                 });
             }
-            return multi.ok ? 0 : 1;
+            return finish(multi.ok ? 0 : 1);
         }
         const worktreeRoot = worktrees[0]?.repo_root ?? primaryRoot;
         const context = await startLocalWorkContext({
@@ -935,6 +1174,7 @@ async function runOnboard(command, io) {
             writeLine(io.stdout, `Ticket: ${context.active_ticket_id ?? "general ambient"}`);
             writeLine(io.stdout, `Context: ${context.work_context_id}`);
         }
+        addInstallEvent(installEvents, "work_context", "ok");
         const run = await runAttributedWorktreeSync({
             homeDir: command.homeDir,
             dashboardUrl: command.dashboardUrl,
@@ -952,6 +1192,7 @@ async function runOnboard(command, io) {
             branch: command.branch,
         });
         if (sync.status !== "uploaded") {
+            addInstallEvent(installEvents, "sync", "fail", "sync_blocked");
             if (command.json) {
                 writeLine(io.stdout, JSON.stringify({
                     ...onboardResult("blocked", resolvedCommand, install, pair, sync, status),
@@ -965,11 +1206,14 @@ async function runOnboard(command, io) {
                 writeLine(io.stderr, `Failure: ${sync.failure_reason}`);
                 writeLine(io.stderr, `Retry: ${sync.retry_command}`);
             }
-            return 1;
+            return finish(1);
         }
+        addInstallEvent(installEvents, "sync", "ok");
         if (command.json) {
             agentRules = await refreshOnboardAgentRules(resolvedCommand, collectionRoots, io);
+            addInstallEvent(installEvents, "agent_rules", "ok");
             autostart = await refreshOnboardAutostart(resolvedCommand, collectionRoots, io);
+            addAutostartInstallEvent(installEvents, autostart);
             writeLine(io.stdout, JSON.stringify({
                 ...onboardResult("pass", resolvedCommand, install, pair, sync, status),
                 collection_roots: collectionRoots,
@@ -979,7 +1223,7 @@ async function runOnboard(command, io) {
                 backfill_hint: backfillHint,
                 codex_sessions: run.summary,
             }, null, 2));
-            return 0;
+            return finish(0);
         }
         writeLine(io.stdout, "4/5 Ambient metadata uploaded.");
         writeLine(io.stdout, `HTTP: ${sync.http_status}`);
@@ -994,7 +1238,9 @@ async function runOnboard(command, io) {
         writeLine(io.stdout, "PASS: Cockpit collector is ready for harvest.");
         writeLine(io.stdout, `Open: ${command.dashboardUrl}/my-work`);
         agentRules = await refreshOnboardAgentRules(resolvedCommand, collectionRoots, io);
+        addInstallEvent(installEvents, "agent_rules", "ok");
         autostart = await refreshOnboardAutostart(resolvedCommand, collectionRoots, io);
+        addAutostartInstallEvent(installEvents, autostart);
         writeOnboardLiveStatus(io, resolvedCommand, collectionRoots, {
             pair,
             status,
@@ -1004,7 +1250,7 @@ async function runOnboard(command, io) {
             initialSyncOk: true,
             backfillHint,
         });
-        return 0;
+        return finish(0);
     }
     catch (error) {
         const message = errorMessage(error);
@@ -1017,7 +1263,8 @@ async function runOnboard(command, io) {
             }).catch(() => null)
             : null;
         const blocker = classifyOnboardBlocker(message);
-        const nextStep = nextStepForOnboardBlocker(blocker);
+        addOnboardFailureEvent(installEvents, blocker);
+        const nextStep = nextStepForOnboardBlocker(blocker, command);
         if (command.json) {
             writeLine(io.stdout, JSON.stringify({
                 ...onboardResult("blocked", command, install, pair, sync, status),
@@ -1032,7 +1279,7 @@ async function runOnboard(command, io) {
             writeLine(io.stderr, `BLOCKED: ${message}`);
             writeLine(io.stderr, `Next: ${nextStep}`);
         }
-        return 1;
+        return finish(1);
     }
 }
 function canReuseOnboardSession(session, claimedOwnerEmail, dashboardUrl) {
@@ -1317,10 +1564,10 @@ function classifyOnboardBlocker(message) {
         return "ticket_binding";
     return "unknown";
 }
-function nextStepForOnboardBlocker(blocker) {
+function nextStepForOnboardBlocker(blocker, options = {}) {
     switch (blocker) {
         case COLLECTION_ROOT_REQUIRED:
-            return "Run `cockpit onboard --workspace <path>` or rerun in a terminal and confirm the collection root.";
+            return missingCollectionRootMessage(options);
         case "ticket":
         case "ticket_binding":
             return "Run `cockpit start --ticket <id>` when actual ticket work begins, then run `cockpit sync`.";
@@ -1435,6 +1682,7 @@ async function runSyncLocked(command, io) {
     });
     if (worktrees.length > 1) {
         const rows = run.outcomes.map((outcome) => worktreeSyncRow(outcome, run));
+        const gc = run.ok ? await runSyncRawEvidenceGc(command, io) : null;
         if (command.json) {
             writeLine(io.stdout, JSON.stringify({
                 mode: "multi_repo",
@@ -1442,6 +1690,7 @@ async function runSyncLocked(command, io) {
                 results: run.outcomes.map((outcome) => outcome.sync),
                 repos: rows,
                 codex_sessions: run.summary,
+                raw_evidence_gc: gc,
             }, null, 2));
             return run.ok ? 0 : 1;
         }
@@ -1453,14 +1702,17 @@ async function runSyncLocked(command, io) {
             writeLine(uploaded ? io.stdout : io.stderr, `- ${worktree.repo_label}/${worktree.worktree_label} (${worktree.branch}) head:${shortSha(sync.head_sha ?? worktree.head_sha)} ${sync.status} objects:${sync.raw_evidence_uploaded_object_count} chunks:${sync.raw_evidence_uploaded_chunk_count} reused:${sync.raw_evidence_reused_count} failed:${sync.raw_evidence_failed_count} cursor:${sync.cursor_tracked_object_count}${failureSuffix}`);
         }
         writeAgentSessionSummary(io, run.summary);
+        if (gc && !gc.skipped)
+            writeLine(io.stdout, rawEvidenceGcSummary(gc));
         return run.ok ? 0 : 1;
     }
     const result = run.outcomes[0]?.sync;
     if (!result) {
         throw new Error("Sync produced no result for the repo worktree.");
     }
+    const gc = result.status === "uploaded" ? await runSyncRawEvidenceGc(command, io) : null;
     if (command.json) {
-        writeLine(io.stdout, JSON.stringify({ ...result, codex_sessions: run.summary }, null, 2));
+        writeLine(io.stdout, JSON.stringify({ ...result, codex_sessions: run.summary, raw_evidence_gc: gc }, null, 2));
         return result.status === "uploaded" ? 0 : 1;
     }
     if (result.status === "uploaded") {
@@ -1474,6 +1726,8 @@ async function runSyncLocked(command, io) {
         writeLine(io.stdout, rawEvidenceSyncLine(result));
         writeAgentSessionSummary(io, run.summary);
         writeLine(io.stdout, cursorStatusLine(result));
+        if (gc && !gc.skipped)
+            writeLine(io.stdout, rawEvidenceGcSummary(gc));
         return 0;
     }
     writeLine(io.stderr, "Cockpit ambient upload failed; safe retry metadata was spooled.");
@@ -1482,6 +1736,9 @@ async function runSyncLocked(command, io) {
     writeLine(io.stderr, `Retry: ${result.retry_command}`);
     return 1;
 }
+async function runSyncRawEvidenceGc(command, io) {
+    return runRawEvidenceLocalGc(getCollectorRuntimePaths(command.homeDir), io.env);
+}
 async function runStatus(command, io) {
     const backfillCursor = await inspectBackfillCursor(command.homeDir);
     const worktrees = await discoverCommandWorktrees(command.repoRoot, { maxDepth: command.maxDepth, maxRepos: command.maxRepos }, io);

package/dist/onboarding-roots.js

@@ -1,67 +1,101 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { discoverGitWorktrees } from "./repo-identity.js";
 import { normalizeCollectionRoots } from "./root-normalization.js";
 export const COLLECTION_ROOT_REQUIRED = "collection_root_required";
+export const HOME_ROOT_CONSENT_PROMPT = "Collect your ENTIRE home folder? Any git repo you ever create under it will be collected automatically. Type 'everything' to confirm: ";
 export async function resolveOnboardingRoots(options) {
-    const explicitRoots = normalizeRoots(options.explicitRoots ?? []);
-    if (explicitRoots.length > 0) {
-        return { roots: explicitRoots, source: "explicit", confirmed: true };
+    const explicitInput = options.explicitRoots ?? [];
+    const explicit = normalizeRootsDetailed(explicitInput, {
+        homeDir: options.homeDir,
+        allowHomeRoot: options.allowHomeRoot,
+    });
+    if (explicit.roots.length > 0) {
+        explainRejectedRoots(options, explicit.rejected);
+        return resolvedRoots(options, explicit.roots, "explicit", true);
     }
-    const savedRoots = normalizeRoots([
+    if (hasRootInput(explicitInput) && explicit.rejected.length > 0) {
+        if (!options.interactive) {
+            throw new Error(`${COLLECTION_ROOT_REQUIRED}: ${rootRejectionExplanation(explicit.rejected[0], options)}`);
+        }
+        explainRejectedRoots(options, explicit.rejected);
+        const homeOffer = await counterOfferHomeDirectoryRepos(options, explicit.rejected);
+        if (homeOffer)
+            return homeOffer;
+        const homeOptIn = await promptForHomeRootOptIn(options, explicit.rejected);
+        if (homeOptIn)
+            return homeOptIn;
+        return promptForRoots(options, "Collection root(s), comma-separated: ");
+    }
+    const savedRoots = normalizeRootsDetailed([
         ...(options.savedRoots ?? []),
         ...(options.config?.default_repo_paths ?? []),
-    ]);
+    ], {
+        homeDir: options.homeDir,
+        allowHomeRoot: options.allowHomeRoot,
+    }).roots;
     if (savedRoots.length > 0) {
         if (!options.interactive) {
-            return { roots: savedRoots, source: "saved", confirmed: false };
+            return resolvedRoots(options, savedRoots, "saved", false);
         }
         const confirmed = await requirePrompt(options).confirm(savedRootsPrompt(savedRoots));
         if (confirmed) {
-            return { roots: savedRoots, source: "saved", confirmed: true };
+            return resolvedRoots(options, savedRoots, "saved", true);
         }
         return promptForRoots(options, "Collection root(s), comma-separated: ");
     }
     if (!options.interactive) {
-        throw new Error(`${COLLECTION_ROOT_REQUIRED}: pass --workspace <path> or run cockpit onboard in a terminal to confirm a collection root.`);
+        throw new Error(`${COLLECTION_ROOT_REQUIRED}: ${missingCollectionRootMessage(options)}`);
     }
     const cwd = path.resolve(options.cwd ?? process.cwd());
     const cwdRoot = likelyBliRootFromCwd(cwd);
     if (cwdRoot) {
         const confirmed = await requirePrompt(options).confirm(`Collect from ${cwdRoot}? [Y/n] `);
         if (confirmed) {
-            return { roots: [cwdRoot], source: "cwd_likely_root", confirmed: true };
+            return resolvedRoots(options, [cwdRoot], "cwd_likely_root", true);
         }
     }
     const homeRoot = path.join(options.homeDir ?? os.homedir(), "BLI");
     if (await directoryExists(homeRoot)) {
         const confirmed = await requirePrompt(options).confirm(`I found ${homeRoot}. Collect from there? [Y/n] `);
         if (confirmed) {
-            return { roots: [path.resolve(homeRoot)], source: "home_likely_root", confirmed: true };
+            return resolvedRoots(options, [path.resolve(homeRoot)], "home_likely_root", true);
         }
     }
     return promptForRoots(options, "Collection root(s), comma-separated: ");
 }
 export function normalizeRoots(roots) {
+    return normalizeRootsDetailed(roots).roots;
+}
+export function normalizeRootsDetailed(roots, options = {}) {
     const seen = new Set();
     const candidates = [];
+    const rejected = [];
+    const homeDir = path.resolve(options.homeDir ?? os.homedir());
     for (const root of roots) {
         const trimmed = root.trim();
         if (!trimmed)
             continue;
         for (const candidate of splitRootInput(trimmed)) {
             const resolved = path.resolve(candidate);
-            if (resolved === path.parse(resolved).root)
-                continue;
-            if (resolved === os.homedir())
+            if (resolved === path.parse(resolved).root) {
+                rejected.push({ input: candidate, reason: "fs_root" });
                 continue;
+            }
+            if (resolved === homeDir) {
+                if (!options.allowHomeRoot) {
+                    rejected.push({ input: candidate, reason: "home_dir" });
+                    continue;
+                }
+            }
             if (seen.has(resolved))
                 continue;
             seen.add(resolved);
             candidates.push(resolved);
         }
     }
-    return normalizeCollectionRoots(candidates);
+    return { roots: normalizeCollectionRoots(candidates), rejected };
 }
 function splitRootInput(value) {
     return value
@@ -71,11 +105,29 @@ function splitRootInput(value) {
 }
 async function promptForRoots(options, message) {
     const prompt = requirePrompt(options);
-    const roots = normalizeRoots([await prompt.input(message)]);
-    if (roots.length === 0) {
-        throw new Error(`${COLLECTION_ROOT_REQUIRED}: no collection root confirmed; pass --workspace <path>.`);
+    for (let attempt = 1; attempt <= 3; attempt += 1) {
+        const detailed = normalizeRootsDetailed([await prompt.input(message)], {
+            homeDir: options.homeDir,
+            allowHomeRoot: options.allowHomeRoot,
+        });
+        if (detailed.roots.length > 0) {
+            explainRejectedRoots(options, detailed.rejected);
+            return resolvedRoots(options, detailed.roots, "prompt", true);
+        }
+        if (detailed.rejected.length > 0) {
+            explainRejectedRoots(options, detailed.rejected);
+            const homeOffer = await counterOfferHomeDirectoryRepos(options, detailed.rejected);
+            if (homeOffer)
+                return homeOffer;
+            const homeOptIn = await promptForHomeRootOptIn(options, detailed.rejected);
+            if (homeOptIn)
+                return homeOptIn;
+        }
+        else {
+            prompt.message?.(missingCollectionRootMessage(options));
+        }
     }
-    return { roots, source: "prompt", confirmed: true };
+    throw new Error(`${COLLECTION_ROOT_REQUIRED}: ${missingCollectionRootMessage(options)}`);
 }
 function savedRootsPrompt(roots) {
     if (roots.length === 1) {
@@ -93,6 +145,119 @@ function requirePrompt(options) {
     }
     return options.prompt;
 }
+function hasRootInput(inputs) {
+    return inputs.some((input) => input.trim().length > 0);
+}
+function explainRejectedRoots(options, rejections) {
+    if (!options.interactive || rejections.length === 0)
+        return;
+    const prompt = requirePrompt(options);
+    for (const rejection of rejections) {
+        prompt.message?.(rootRejectionPromptHint(rejection, options));
+    }
+}
+export function rootRejectionExplanation(rejection, options = {}) {
+    switch (rejection.reason) {
+        case "home_dir":
+            return homeRootTutorial(options.homeDir);
+        case "fs_root":
+            return filesystemRootTutorial(options.homeDir);
+    }
+}
+function rootRejectionPromptHint(rejection, options = {}) {
+    switch (rejection.reason) {
+        case "home_dir":
+            return homeRootTutorial(options.homeDir);
+        case "fs_root":
+            return filesystemRootTutorial(options.homeDir);
+    }
+}
+async function counterOfferHomeDirectoryRepos(options, rejections) {
+    const homeRejection = rejections.find((rejection) => rejection.reason === "home_dir");
+    if (!homeRejection)
+        return null;
+    const prompt = requirePrompt(options);
+    const homeDir = path.resolve(options.homeDir ?? os.homedir());
+    const discover = options.discoverGitWorktrees ?? discoverGitWorktrees;
+    const worktrees = await discover(homeDir, {
+        maxDepth: 3,
+        maxWorktrees: 50,
+    }).catch(() => []);
+    const roots = normalizeCollectionRoots([...new Set(worktrees.map((worktree) => path.resolve(worktree.repo_root)))]);
+    if (roots.length === 0)
+        return null;
+    const confirmed = await prompt.confirm([
+        "Your home folder can't be a collection root by default:",
+        `  I found ${roots.length} git repos under ${homeDir} that are safer to collect.`,
+        "Discovered repos:",
+        ...roots.map((root) => `- ${root}`),
+        "What you can do:",
+        "  1) Use these repos: answer y",
+        "  2) Pick different folders: answer n, then paste specific paths",
+        "  3) Collect everything anyway: answer n, then type everything at the next prompt",
+        "Collect from these? [Y/n] ",
+    ].join("\n"));
+    return confirmed ? resolvedRoots(options, roots, "prompt", true) : null;
+}
+async function promptForHomeRootOptIn(options, rejections) {
+    if (!rejections.some((rejection) => rejection.reason === "home_dir"))
+        return null;
+    const answer = await requirePrompt(options).input(HOME_ROOT_CONSENT_PROMPT);
+    if (answer.trim().toLowerCase() !== "everything")
+        return null;
+    return {
+        roots: [path.resolve(options.homeDir ?? os.homedir())],
+        source: "prompt",
+        confirmed: true,
+        homeRootOptIn: true,
+    };
+}
+function resolvedRoots(options, roots, source, confirmed) {
+    const result = { roots, source, confirmed };
+    if (options.allowHomeRoot && roots.some((root) => isHomeRoot(root, options.homeDir))) {
+        result.homeRootOptIn = true;
+    }
+    return result;
+}
+function isHomeRoot(root, homeDir) {
+    return path.resolve(root) === path.resolve(homeDir ?? os.homedir());
+}
+function homeRootTutorial(homeDirInput) {
+    const homeDir = path.resolve(homeDirInput ?? os.homedir());
+    const bliRoot = path.join(homeDir, "BLI");
+    const otherRoot = path.join(homeDir, "other");
+    return [
+        "Your home folder can't be a collection root by default:",
+        `  scanning all of ${homeDir} would include personal folders and every repo you ever create.`,
+        "What you can do:",
+        `  1) Specific folders: cockpit onboard --workspace "${bliRoot},${otherRoot}"`,
+        "  2) One work parent: mkdir ~/BLI && move your repos in, then: cockpit onboard --workspace ~/BLI",
+        "  3) Collect everything anyway (company machine): rerun with --allow-home-root",
+    ].join("\n");
+}
+function filesystemRootTutorial(homeDirInput) {
+    const homeDir = path.resolve(homeDirInput ?? os.homedir());
+    const bliRoot = path.join(homeDir, "BLI");
+    const otherRoot = path.join(homeDir, "other");
+    return [
+        "Your filesystem root can't be a collection root:",
+        `  scanning all of ${path.parse(homeDir).root} would include system folders, private data, and every mounted repo.`,
+        "What you can do:",
+        `  1) Specific folders: cockpit onboard --workspace "${bliRoot},${otherRoot}"`,
+        "  2) One work parent: mkdir ~/BLI && move your repos in, then: cockpit onboard --workspace ~/BLI",
+    ].join("\n");
+}
+export function missingCollectionRootMessage(options = {}) {
+    const homeDir = path.resolve(options.homeDir ?? os.homedir());
+    return [
+        "No collection root was confirmed:",
+        "  Cockpit only scans folders you name or confirm.",
+        "What you can do:",
+        `  1) Paste one work parent: ${path.join(homeDir, "BLI")}`,
+        `  2) Paste specific folders: ${path.join(homeDir, "repo-a")},${path.join(homeDir, "repo-b")}`,
+        "  3) Stop and rerun with a flag: cockpit onboard --workspace ~/BLI",
+    ].join("\n");
+}
 function likelyBliRootFromCwd(cwd) {
     const parts = cwd.split(path.sep).filter(Boolean);
     const index = parts.lastIndexOf("BLI");

package/dist/raw-evidence-gc.js

@@ -0,0 +1,122 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { readRawEvidenceCursor } from "./cursors/raw-evidence-cursor.js";
+const RAW_EVIDENCE_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+const SYNC_LOG_MAX_BYTES = 50 * 1024 * 1024;
+// GC hashes every file in every old-but-kept dir to confirm uploads. Running
+// that on each 15-min sync would re-read the same gigabytes ~96x/day on
+// machines with unconfirmed evidence, so GC is throttled to once per day.
+const GC_MIN_INTERVAL_MS = 24 * 60 * 60 * 1000;
+export async function runRawEvidenceLocalGc(paths, env = process.env, now = new Date()) {
+    if (env["COCKPIT_DISABLE_GC"] === "1") {
+        return {
+            skipped: true,
+            removed_dirs: 0,
+            freed_bytes: 0,
+            rotated_sync_log: false,
+        };
+    }
+    const throttleMarker = path.join(paths.state_dir, ".last-raw-evidence-gc");
+    const lastRun = await fs.stat(throttleMarker).catch(() => null);
+    if (lastRun && now.getTime() - lastRun.mtimeMs < GC_MIN_INTERVAL_MS) {
+        return {
+            skipped: true,
+            removed_dirs: 0,
+            freed_bytes: 0,
+            rotated_sync_log: false,
+        };
+    }
+    await fs.mkdir(paths.state_dir, { recursive: true }).catch(() => undefined);
+    await fs.writeFile(throttleMarker, now.toISOString()).catch(() => undefined);
+    const cursor = await readRawEvidenceCursor(paths);
+    const uploadedHashes = new Set(Object.keys(cursor.objects));
+    const rawEvidenceRoot = path.join(paths.state_dir, "raw-evidence");
+    const entries = await fs.readdir(rawEvidenceRoot, { withFileTypes: true }).catch(() => []);
+    let removedDirs = 0;
+    let freedBytes = 0;
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.startsWith("work-"))
+            continue;
+        const dir = path.join(rawEvidenceRoot, entry.name);
+        const dirStats = await fs.stat(dir).catch(() => null);
+        if (!dirStats?.isDirectory())
+            continue;
+        if (now.getTime() - dirStats.mtimeMs < RAW_EVIDENCE_RETENTION_MS)
+            continue;
+        const inspection = await inspectRawEvidenceDirForGc(dir, uploadedHashes);
+        if (!inspection.deletable)
+            continue;
+        await fs.rm(dir, { recursive: true, force: true }).catch(() => undefined);
+        if (await exists(dir))
+            continue;
+        removedDirs += 1;
+        freedBytes += inspection.byteSize;
+    }
+    return {
+        skipped: false,
+        removed_dirs: removedDirs,
+        freed_bytes: freedBytes,
+        rotated_sync_log: await rotateSyncLog(paths),
+    };
+}
+export function rawEvidenceGcSummary(result) {
+    return `raw-evidence GC: removed ${result.removed_dirs} dirs, freed ~${formatMb(result.freed_bytes)} MB`;
+}
+async function inspectRawEvidenceDirForGc(dir, uploadedHashes) {
+    const files = await listFiles(dir).catch(() => null);
+    if (!files)
+        return { deletable: false, byteSize: 0 };
+    if (files.length === 0)
+        return { deletable: true, byteSize: 0 };
+    let byteSize = 0;
+    for (const file of files) {
+        const bytes = await fs.readFile(file).catch(() => null);
+        if (!bytes)
+            return { deletable: false, byteSize: 0 };
+        const digest = crypto.createHash("sha256").update(bytes).digest("hex");
+        if (!uploadedHashes.has(digest)) {
+            return { deletable: false, byteSize: 0 };
+        }
+        byteSize += bytes.byteLength;
+    }
+    return { deletable: true, byteSize };
+}
+async function listFiles(root) {
+    const files = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        const entries = await fs.readdir(current, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(full);
+            }
+            else if (entry.isFile()) {
+                files.push(full);
+            }
+            else {
+                throw new Error("raw-evidence directory contains unsupported entry");
+            }
+        }
+    }
+    return files;
+}
+async function rotateSyncLog(paths) {
+    const syncLog = path.join(paths.state_dir, "sync.log");
+    const info = await fs.stat(syncLog).catch(() => null);
+    if (!info?.isFile() || info.size <= SYNC_LOG_MAX_BYTES)
+        return false;
+    await fs.truncate(syncLog, 0).catch(() => undefined);
+    const after = await fs.stat(syncLog).catch(() => null);
+    return after?.isFile() === true && after.size === 0;
+}
+async function exists(target) {
+    return fs.stat(target).then(() => true, () => false);
+}
+function formatMb(bytes) {
+    return (bytes / (1024 * 1024)).toFixed(2);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "private": false,
   "type": "module",
   "bin": {