@bli-cockpit/cli 0.1.22 → 0.1.24

package/dist/commands/local-args.js

@@ -74,6 +74,7 @@ function parseOnboardArgs(args) {
         kind: "onboard",
         homeDir: optionalNonEmpty(values.flags.get("--home")),
         repoRoot: optionalNonEmpty(workRootFlagValue(values)),
+        collectionRoots: optionalNonEmptyList(workRootFlagValues(values)),
         dashboardUrl: normalizeUrl(values.flags.get("--dashboard-url") ?? DEFAULT_DASHBOARD_URL),
         claimedOwnerEmail: optionalEmail(values.flags.get("--email")),
         deviceName: optionalNonEmpty(values.flags.get("--device-name")),
@@ -403,6 +404,7 @@ function parseNamedArgs(args, options) {
     const allowed = new Set(options.allowedFlags);
     const valueFlags = new Set(options.valueFlags);
     const flags = new Map();
+    const flagValues = new Map();
     const booleans = new Set();
     const positionals = [];
     for (let index = 0; index < args.length; index += 1) {
@@ -422,6 +424,9 @@ function parseNamedArgs(args, options) {
             }
             rejectServiceRoleLikeArgument(value);
             flags.set(flag, value);
+            const existing = flagValues.get(flag) ?? [];
+            existing.push(value);
+            flagValues.set(flag, existing);
             if (inlineValue === undefined)
                 index += 1;
         }
@@ -431,7 +436,7 @@ function parseNamedArgs(args, options) {
             booleans.add(flag);
         }
     }
-    return { flags, booleans, positionals };
+    return { flags, flagValues, booleans, positionals };
 }
 function workRootFlagValue(values) {
     const provided = WORK_ROOT_FLAGS.filter((flag) => values.flags.has(flag));
@@ -443,6 +448,19 @@ function workRootFlagValue(values) {
     }
     return values.flags.get("--workspace") ?? values.flags.get("--repo");
 }
+function workRootFlagValues(values) {
+    const roots = [];
+    for (const flag of WORK_ROOT_FLAGS) {
+        roots.push(...(values.flagValues.get(flag) ?? []));
+    }
+    return roots;
+}
+function optionalNonEmptyList(values) {
+    const filtered = values
+        .map((value) => optionalNonEmpty(value))
+        .filter((value) => Boolean(value));
+    return filtered.length > 0 ? filtered : undefined;
+}
 function assertNoPositionals(positionals, command) {
     if (positionals.length > 0) {
         throw new Error(`${command} does not accept positional arguments.`);

package/dist/commands/local.js

@@ -4,13 +4,14 @@ import path from "node:path";
 import { createCollectorServer } from "../server.js";
 import { inspectAgentRules, installAgentRules, uninstallAgentRules, } from "../agent-rules.js";
 import { parseLocalArgs, normalizeUrl } from "./local-args.js";
-import { autostartStatus, installAutostartAgent, uninstallAutostartAgent } from "../autostart.js";
-import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, inspectLocalCollectorStatus, installLocalCollector, logoutLocalCollector, pairLocalCollector, readLocalCollectorSessionFile, readLocalSessionReference, startLocalWorkContext } from "../local-state.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 { scanAndAttributeCodexSessions } from "../adapters/codex-attribution.js";
 import { scanAndAttributeClaudeSessions } from "../adapters/claude-attribution.js";
 import { acquireSyncLock } from "../sync-lock.js";
 import { discoverGitWorktrees } from "../repo-identity.js";
-import { runAttributedWorktreeSync } from "./session-sync.js";
+import { runAttributedWorktreeSync, } from "./session-sync.js";
+import { COLLECTION_ROOT_REQUIRED, resolveOnboardingRoots, } from "../onboarding-roots.js";
 export const rootCommandNames = new Set([
     "onboard",
     "install",
@@ -281,68 +282,112 @@ async function promptOnboardEmail(io) {
     }
     return answer;
 }
+function onboardingRootPrompt(io) {
+    return {
+        confirm: async (message) => yesByDefault(await readLine(io, message)),
+        input: (message) => readLine(io, message),
+    };
+}
+function yesByDefault(raw) {
+    const answer = raw.trim().split(/\s+/u)[0]?.toLowerCase() ?? "";
+    return answer !== "n" && answer !== "no";
+}
+async function resolveOnboardEmail(command, roots, config, io) {
+    if (command.claimedOwnerEmail)
+        return command.claimedOwnerEmail;
+    const inferred = await inferOnboardEmail(command.homeDir, roots, config);
+    const interactive = !command.json && isInteractiveStdin(io);
+    if (!inferred) {
+        return interactive ? promptOnboardEmail(io) : undefined;
+    }
+    if (inferred.source === "session") {
+        if (!command.json)
+            writeLine(io.stdout, `Dashboard email: ${inferred.email}`);
+        return inferred.email;
+    }
+    if (!interactive)
+        return inferred.email;
+    const answer = (await readLine(io, `Use ${inferred.email} for Cockpit pairing? [Y/n] `)).trim().toLowerCase();
+    const typedEmail = answer.split(/\s+/u).find((part) => part.includes("@"));
+    if (typedEmail)
+        return typedEmail;
+    if (yesByDefault(answer)) {
+        return inferred.email;
+    }
+    return promptOnboardEmail(io);
+}
+async function inferOnboardEmail(homeDir, roots, config) {
+    const session = await readOnboardSessionReuseCandidate(homeDir).catch(() => null);
+    const sessionEmail = normalizeEmailForComparison(session?.email);
+    if (session?.session_state === "valid" && sessionEmail) {
+        return { email: sessionEmail, source: "session" };
+    }
+    const configEmail = normalizeEmailForComparison(config?.claimed_owner_email);
+    if (configEmail)
+        return { email: configEmail, source: "config" };
+    const gitEmail = await inferUniqueGitEmail(roots);
+    return gitEmail ? { email: gitEmail, source: "git" } : null;
+}
+async function inferUniqueGitEmail(roots) {
+    const emails = new Set();
+    for (const root of roots) {
+        const email = await readGitConfigEmail(root);
+        if (email)
+            emails.add(email);
+    }
+    return emails.size === 1 ? [...emails][0] ?? null : null;
+}
+async function readGitConfigEmail(root) {
+    return new Promise((resolve) => {
+        execFile("git", ["config", "user.email"], { cwd: root, encoding: "utf8" }, (error, stdout) => {
+            if (error) {
+                resolve(null);
+                return;
+            }
+            const email = normalizeEmailForComparison(stdout);
+            resolve(email?.includes("@") ? email : null);
+        });
+    });
+}
 /**
- * After a successful onboard, offers to install the launchd autostart agent so a
- * Mac mini keeps syncing without anyone re-running cockpit — this is the fix for
- * interns drifting to Stale. Only in an interactive, non-JSON run with a real
- * exec runner (`io.exec`): headless / piped / spawned onboards and tests that
- * pass no exec skip it entirely. Declining leaves onboarding's success untouched.
+ * After a successful onboard, refreshes the launchd autostart agent so intern
+ * machines keep syncing without anyone re-running Cockpit. Runtimes without an
+ * exec runner skip this because launchd installation cannot be attempted there.
  */
-async function maybeOfferAutostart(command, io) {
-    if (command.json || !isInteractiveStdin(io) || !io.exec)
-        return;
-    const answer = (await readLine(io, "Keep Cockpit syncing in the background, even after restart? [Y/n] "))
-        .trim()
-        .toLowerCase();
-    if (answer === "n" || answer === "no") {
-        writeLine(io.stdout, "Skipped background autostart. Run `cockpit autostart install` anytime.");
-        return;
-    }
+async function refreshOnboardAutostart(command, roots, io) {
+    if (!io.exec)
+        return null;
     const result = await installAutostartAgent({
         homeDir: command.homeDir,
-        repoRoot: command.repoRoot,
+        repoRoot: roots[0],
+        repoRoots: roots,
         dashboardUrl: command.dashboardUrl,
         exec: io.exec,
     });
+    if (command.json)
+        return result;
     if (result.status === "unsupported") {
         writeLine(io.stdout, `Background autostart unsupported: ${result.message}`);
-        return;
+        return result;
     }
     writeLine(io.stdout, result.loaded
-        ? "Background autostart installed; Cockpit syncs at login and every 15 min."
-        : "Background autostart installed, but launchctl load reported a problem; check `cockpit autostart status`.");
+        ? "Background autostart refreshed; Cockpit syncs at login and every 15 min."
+        : "Background autostart refreshed, but launchctl load reported a problem; check `cockpit autostart status`.");
     writeLine(io.stdout, `Plist: ${result.plist_path}`);
+    return result;
 }
-async function maybeOfferAgentRules(command, io) {
-    if (command.json || !isInteractiveStdin(io))
-        return;
-    const scopePath = path.resolve(command.repoRoot ?? process.cwd());
-    const current = await inspectAgentRules({
+async function refreshOnboardAgentRules(command, roots, io) {
+    const result = await installAgentRules({
         homeDir: command.homeDir,
-        scopePath,
+        scopePaths: roots,
     });
-    if (current.installed) {
-        writeLine(io.stdout, onboardAgentRulesAlreadyInstalledLine(current));
-        return;
-    }
-    const answer = (await readLine(io, `Add Cockpit ticket-binding rules scoped to ${scopePath} to AGENTS.md and CLAUDE.md? [Y/n] `))
-        .trim()
-        .toLowerCase();
-    if (answer === "n" || answer === "no") {
-        writeLine(io.stdout, "Skipped agent rules. Run `cockpit agent-rules install --workspace \"$PWD\"` anytime.");
-        return;
-    }
-    const result = await installAgentRules({ homeDir: command.homeDir, scopePath });
+    if (command.json)
+        return result;
     writeLine(io.stdout, `Agent rules: ${onboardAgentRulesInstallLine(result)}`);
     for (const target of result.targets) {
         writeLine(io.stdout, `${agentRuleHostLabel(target.host)}: ${target.rules_file}`);
     }
-}
-function onboardAgentRulesAlreadyInstalledLine(result) {
-    const hasEquivalent = result.targets.some((target) => target.state === "equivalent");
-    return hasEquivalent
-        ? "Agent rules: matching Cockpit ticket-binding guidance already exists."
-        : "Agent rules: already current in AGENTS.md and CLAUDE.md.";
+    return result;
 }
 function onboardAgentRulesInstallLine(result) {
     if (result.targets.some((target) => target.stale_block_replaced)) {
@@ -359,24 +404,78 @@ function onboardAgentRulesInstallLine(result) {
             return "not installed.";
     }
 }
+function writeOnboardLiveStatus(io, command, roots, options) {
+    writeLine(io.stdout, "You're live.");
+    writeLine(io.stdout, "Collecting from:");
+    for (const root of roots)
+        writeLine(io.stdout, `- ${root}`);
+    writeLine(io.stdout, `Paired user: ${options.pair?.session.email ??
+        options.pair?.session.auth_subject_id ??
+        (options.status?.session_state === "valid" ? "existing valid session" : "pending")}`);
+    writeLine(io.stdout, `Background sync: ${backgroundSyncLine(options.autostart)}`);
+    writeLine(io.stdout, `Initial sync: ${options.initialSyncOk ? options.sync?.status ?? "uploaded" : "blocked"}`);
+    writeLine(io.stdout, `Agent rules: ${options.agentRules ? onboardAgentRulesInstallLine(options.agentRules) : "not refreshed"}`);
+    writeLine(io.stdout, `Dashboard: ${command.dashboardUrl}/my-work`);
+    writeLine(io.stdout, "Next: cockpit status");
+}
+function backgroundSyncLine(result) {
+    if (!result)
+        return "not refreshed (launchd runner unavailable)";
+    if (result.status === "unsupported")
+        return `unsupported (${result.message})`;
+    if (result.status === "installed" && result.loaded)
+        return "installed";
+    if (result.status === "installed") {
+        return `installed with warning (${result.message ?? "launchctl load failed"})`;
+    }
+    return result.status;
+}
 async function runOnboard(command, io) {
     let install = null;
     let pair = null;
     let sync = null;
     let status = null;
+    let rootsResult = null;
+    let agentRules = null;
+    let autostart = null;
     try {
         if (!command.json) {
             writeLine(io.stdout, "Cockpit harvest onboarding");
             writeLine(io.stdout, `Dashboard: ${command.dashboardUrl}`);
             writeLine(io.stdout, `Ticket: ${command.activeTicketId ?? "general ambient"}`);
         }
-        let claimedOwnerEmail = command.claimedOwnerEmail;
-        if (!claimedOwnerEmail && !command.json && isInteractiveStdin(io)) {
-            claimedOwnerEmail = await promptOnboardEmail(io);
+        const paths = getCollectorRuntimePaths(command.homeDir);
+        const existingConfig = await readLocalCollectorConfig(paths).catch(() => null);
+        const interactive = !command.json && isInteractiveStdin(io);
+        rootsResult = await resolveOnboardingRoots({
+            homeDir: command.homeDir,
+            explicitRoots: command.collectionRoots ?? (command.repoRoot ? [command.repoRoot] : []),
+            config: existingConfig,
+            interactive,
+            prompt: interactive ? onboardingRootPrompt(io) : undefined,
+        });
+        const collectionRoots = rootsResult.roots;
+        const primaryRoot = collectionRoots[0];
+        if (!primaryRoot) {
+            throw new Error(`${COLLECTION_ROOT_REQUIRED}: no collection root confirmed.`);
+        }
+        const resolvedCommand = {
+            ...command,
+            repoRoot: primaryRoot,
+            collectionRoots,
+        };
+        const replaceRepoRoots = rootsResult.source === "prompt" &&
+            !command.collectionRoots?.length &&
+            (existingConfig?.default_repo_paths.length ?? 0) > 0;
+        if (!command.json) {
+            writeLine(io.stdout, `Collecting from: ${collectionRoots.join(", ")}`);
         }
+        const claimedOwnerEmail = await resolveOnboardEmail(resolvedCommand, collectionRoots, existingConfig, io);
         install = await installLocalCollector({
             homeDir: command.homeDir,
-            repoRoot: command.repoRoot,
+            repoRoot: primaryRoot,
+            repoRoots: collectionRoots,
+            replaceRepoRoots,
             dashboardUrl: command.dashboardUrl,
             deviceName: command.deviceName,
         });
@@ -386,7 +485,7 @@ async function runOnboard(command, io) {
         }
         const installedStatus = await inspectLocalCollectorStatus({
             homeDir: command.homeDir,
-            repoRoot: command.repoRoot,
+            repoRoot: primaryRoot,
             branch: command.branch,
         });
         const installedSession = await readOnboardSessionReuseCandidate(command.homeDir);
@@ -421,26 +520,41 @@ async function runOnboard(command, io) {
                 writeLine(io.stdout, `Device: ${pair.session.device_name ?? pair.session.device_id ?? "unknown"}`);
             }
         }
-        const worktrees = await discoverCommandWorktrees(command.repoRoot, { maxDepth: command.maxDepth, maxRepos: command.maxRepos }, io);
+        const worktrees = await discoverCommandWorktrees(collectionRoots, { maxDepth: command.maxDepth, maxRepos: command.maxRepos }, io);
         if (worktrees.length > 1) {
-            const multi = await runMultiRepoOnboard(command, io, worktrees);
+            const multi = await runMultiRepoOnboard(resolvedCommand, io, worktrees);
+            if (multi.ok) {
+                agentRules = await refreshOnboardAgentRules(resolvedCommand, collectionRoots, io);
+                autostart = await refreshOnboardAutostart(resolvedCommand, collectionRoots, io);
+            }
             if (command.json) {
                 writeLine(io.stdout, JSON.stringify({
-                    ...onboardResult(multi.ok ? "pass" : "blocked", command, install, pair, null, null),
+                    ...onboardResult(multi.ok ? "pass" : "blocked", resolvedCommand, install, pair, null, null),
+                    collection_roots: collectionRoots,
+                    root_resolution: rootsResult,
+                    agent_rules: agentRules,
+                    autostart,
                     mode: "multi_repo",
                     repos: multi.results,
                     codex_sessions: multi.codex_sessions,
                 }, null, 2));
             }
-            if (multi.ok) {
-                await maybeOfferAgentRules(command, io);
-                await maybeOfferAutostart(command, io);
+            if (multi.ok && !command.json) {
+                writeOnboardLiveStatus(io, resolvedCommand, collectionRoots, {
+                    pair,
+                    status,
+                    sync: null,
+                    agentRules,
+                    autostart,
+                    initialSyncOk: true,
+                });
             }
             return multi.ok ? 0 : 1;
         }
+        const worktreeRoot = worktrees[0]?.repo_root ?? primaryRoot;
         const context = await startLocalWorkContext({
             homeDir: command.homeDir,
-            repoRoot: command.repoRoot,
+            repoRoot: worktreeRoot,
             branch: command.branch,
             activeTicketId: command.activeTicketId,
         });
@@ -464,13 +578,15 @@ async function runOnboard(command, io) {
         }
         status = await inspectLocalCollectorStatus({
             homeDir: command.homeDir,
-            repoRoot: command.repoRoot,
+            repoRoot: worktreeRoot,
             branch: command.branch,
         });
         if (sync.status !== "uploaded") {
             if (command.json) {
                 writeLine(io.stdout, JSON.stringify({
-                    ...onboardResult("blocked", command, install, pair, sync, status),
+                    ...onboardResult("blocked", resolvedCommand, install, pair, sync, status),
+                    collection_roots: collectionRoots,
+                    root_resolution: rootsResult,
                     codex_sessions: run.summary,
                 }, null, 2));
             }
@@ -482,8 +598,14 @@ async function runOnboard(command, io) {
             return 1;
         }
         if (command.json) {
+            agentRules = await refreshOnboardAgentRules(resolvedCommand, collectionRoots, io);
+            autostart = await refreshOnboardAutostart(resolvedCommand, collectionRoots, io);
             writeLine(io.stdout, JSON.stringify({
-                ...onboardResult("pass", command, install, pair, sync, status),
+                ...onboardResult("pass", resolvedCommand, install, pair, sync, status),
+                collection_roots: collectionRoots,
+                root_resolution: rootsResult,
+                agent_rules: agentRules,
+                autostart,
                 codex_sessions: run.summary,
             }, null, 2));
             return 0;
@@ -500,22 +622,35 @@ async function runOnboard(command, io) {
         writeLine(io.stdout, `Upload state: ${status.upload_state}`);
         writeLine(io.stdout, "PASS: Cockpit collector is ready for harvest.");
         writeLine(io.stdout, `Open: ${command.dashboardUrl}/my-work`);
-        await maybeOfferAgentRules(command, io);
-        await maybeOfferAutostart(command, io);
+        agentRules = await refreshOnboardAgentRules(resolvedCommand, collectionRoots, io);
+        autostart = await refreshOnboardAutostart(resolvedCommand, collectionRoots, io);
+        writeOnboardLiveStatus(io, resolvedCommand, collectionRoots, {
+            pair,
+            status,
+            sync,
+            agentRules,
+            autostart,
+            initialSyncOk: true,
+        });
         return 0;
     }
     catch (error) {
         const message = errorMessage(error);
-        status = await inspectLocalCollectorStatus({
-            homeDir: command.homeDir,
-            repoRoot: command.repoRoot,
-            branch: command.branch,
-        }).catch(() => null);
+        const statusRoot = rootsResult?.roots[0] ?? command.repoRoot;
+        status = statusRoot
+            ? await inspectLocalCollectorStatus({
+                homeDir: command.homeDir,
+                repoRoot: statusRoot,
+                branch: command.branch,
+            }).catch(() => null)
+            : null;
         const blocker = classifyOnboardBlocker(message);
         const nextStep = nextStepForOnboardBlocker(blocker);
         if (command.json) {
             writeLine(io.stdout, JSON.stringify({
                 ...onboardResult("blocked", command, install, pair, sync, status),
+                collection_roots: rootsResult?.roots ?? [],
+                root_resolution: rootsResult,
                 blocker,
                 message,
                 next_step: nextStep,
@@ -625,6 +760,13 @@ function cursorStatusLine(sync) {
 const DEFAULT_DISCOVERY_MAX_DEPTH = 3;
 const DEFAULT_DISCOVERY_MAX_REPOS = 50;
 async function discoverCommandWorktrees(repoRoot, discovery = {}, io) {
+    if (Array.isArray(repoRoot)) {
+        const discovered = [];
+        for (const root of repoRoot) {
+            discovered.push(...(await discoverCommandWorktrees(root, discovery, io)));
+        }
+        return dedupeWorktrees(discovered);
+    }
     const maxWorktrees = discovery.maxRepos ?? DEFAULT_DISCOVERY_MAX_REPOS;
     const worktrees = await discoverGitWorktrees(repoRoot ?? process.cwd(), {
         maxDepth: discovery.maxDepth ?? DEFAULT_DISCOVERY_MAX_DEPTH,
@@ -638,6 +780,18 @@ async function discoverCommandWorktrees(repoRoot, discovery = {}, io) {
     }
     return worktrees;
 }
+function dedupeWorktrees(worktrees) {
+    const seen = new Set();
+    const deduped = [];
+    for (const worktree of worktrees) {
+        const key = worktree.worktree_fingerprint || path.resolve(worktree.repo_root);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(worktree);
+    }
+    return deduped;
+}
 async function runMultiRepoOnboard(command, io, worktrees) {
     if (!command.json) {
         writeLine(io.stdout, `3/5 Parent folder mode: discovered ${worktrees.length} git worktree(s).`);
@@ -743,6 +897,7 @@ function onboardResult(resultStatus, command, install, pair, sync, status) {
         work_context_id: sync?.work_context_id ?? status?.work_context_id ?? null,
         config_file: install?.paths.config_file ?? status?.config_file ?? null,
         session_file: install?.paths.session_file ?? status?.session_file ?? null,
+        collection_roots: command.collectionRoots ?? (command.repoRoot ? [command.repoRoot] : []),
         paired_user: pair?.session.email ?? pair?.session.auth_subject_id ?? null,
         paired_device: pair?.session.device_name ?? pair?.session.device_id ?? null,
         upload_status: sync?.status ?? null,
@@ -756,6 +911,8 @@ function onboardResult(resultStatus, command, install, pair, sync, status) {
     };
 }
 function classifyOnboardBlocker(message) {
+    if (message.includes(COLLECTION_ROOT_REQUIRED))
+        return COLLECTION_ROOT_REQUIRED;
     if (/ticket/i.test(message))
         return "ticket";
     if (/pair|paired|approval|expired|revoked/i.test(message))
@@ -772,6 +929,8 @@ function classifyOnboardBlocker(message) {
 }
 function nextStepForOnboardBlocker(blocker) {
     switch (blocker) {
+        case COLLECTION_ROOT_REQUIRED:
+            return "Run `cockpit onboard --workspace <path>` or rerun in a terminal and confirm the collection root.";
         case "ticket":
         case "ticket_binding":
             return "Run `cockpit start --ticket <id>` when actual ticket work begins, then run `cockpit sync`.";

package/dist/commands/public-root.js

@@ -23,9 +23,10 @@ function cockpitHelp() {
     localCommandHelp(),
     "",
     "Install/update: `npm install -g @bli-cockpit/cli@latest`.",
-    "Intern path: run `cockpit onboard` from the repo root; add `--ticket <id>` only when work already has a ticket.",
-    "Already onboarded: run `cockpit sync --workspace \"$PWD\" --json`.",
-    "Agent setup: interactive `cockpit onboard` offers AGENTS.md/CLAUDE.md rules; use `cockpit agent-rules install --workspace \"$PWD\"` for repair/headless setup.",
+    "Intern path: run `cockpit onboard`; it confirms a `/BLI` collection root before syncing.",
+    "Headless/reused laptop path: `cockpit onboard --email <email> --workspace ~/BLI`.",
+    "Already onboarded: rerun `cockpit onboard` from anywhere to refresh pairing, roots, agent rules, autostart, and sync.",
+    "Agent setup: `cockpit onboard` refreshes AGENTS.md/CLAUDE.md rules; use `cockpit agent-rules install --workspace ~/BLI` for repair.",
     "Dashboard URL is optional for normal production use; pass `--dashboard-url` only for staging/custom dashboards or forced re-pairing.",
     "Manual collector path: `install`, `login`, `start [--ticket <id>] [--topic <label>] [--intent <intent>] [--phase <phase>]`, `sync`, `status`, `agent-rules`.",
   ].join("\n");

package/dist/evidence-upload-client.js

@@ -1,4 +1,4 @@
-import { RAW_EVIDENCE_UPLOAD_DEFAULT_CHUNK_BYTES, RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, RAW_EVIDENCE_UPLOAD_MAX_OBJECTS_PER_BEGIN, } from "@bli-cockpit/telemetry-core";
+import { RAW_EVIDENCE_UPLOAD_DEFAULT_CHUNK_BYTES, RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, RAW_EVIDENCE_UPLOAD_MAX_OBJECTS_PER_BEGIN, RawEvidenceRedactionMetadataSchema, RawEvidenceUploadCommitResponseSchema, } from "@bli-cockpit/telemetry-core";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 const DEFAULT_MAX_ATTEMPTS = 3;
@@ -114,7 +114,7 @@ export async function uploadRawEvidenceFilesChunked(options) {
 function duplicateOutcome(primary, duplicate) {
     return {
         ...primary,
-        pointer: duplicate.pointer,
+        pointer: pointerWithUploadedMetadata(duplicate.pointer, primary.pointer),
         codex_session_id: duplicate.codex_session_id ?? null,
         kind: duplicate.kind ?? "unknown",
         artifact_metadata: duplicate.artifact_metadata,
@@ -181,9 +181,10 @@ async function uploadOneObject(options, entry, disposition, chunkSizeBytes) {
     const commitStatus = commit.body && typeof commit.body === "object"
         ? commit.body.status
         : undefined;
+    const committedPointer = pointerWithCommitResponse(entry.file.pointer, commit.body);
     if (commitStatus === "already_committed") {
         return {
-            pointer: entry.file.pointer,
+            pointer: committedPointer,
             object_key: objectKey,
             codex_session_id: entry.file.codex_session_id ?? null,
             kind: entry.file.kind ?? "unknown",
@@ -194,7 +195,7 @@ async function uploadOneObject(options, entry, disposition, chunkSizeBytes) {
         };
     }
     return {
-        pointer: entry.file.pointer,
+        pointer: committedPointer,
         object_key: objectKey,
         codex_session_id: entry.file.codex_session_id ?? null,
         kind: entry.file.kind ?? "unknown",
@@ -227,8 +228,9 @@ async function uploadWithLegacyFallback(options, loaded, outcomes) {
             ],
         });
         if (response.ok) {
+            const pointer = pointerWithLegacyUploadResponse(entry.file.pointer, response.body);
             outcome = {
-                pointer: entry.file.pointer,
+                pointer,
                 object_key: entry.file.pointer.object_key ?? "",
                 codex_session_id: entry.file.codex_session_id ?? null,
                 kind: entry.file.kind ?? "unknown",
@@ -331,6 +333,50 @@ function failedOutcome(file, reason, uploadedChunks = 0) {
         uploaded_chunk_count: uploadedChunks,
     };
 }
+function pointerWithCommitResponse(pointer, body) {
+    const parsed = RawEvidenceUploadCommitResponseSchema.safeParse(body);
+    if (!parsed.success)
+        return pointer;
+    return pointerWithUploadedMetadata(pointer, {
+        content_hash_sha256: parsed.data.content_hash_sha256,
+        byte_size: parsed.data.byte_size,
+        redaction: parsed.data.redaction,
+    });
+}
+function pointerWithLegacyUploadResponse(pointer, body) {
+    if (!body || typeof body !== "object")
+        return pointer;
+    const uploaded = body.uploaded;
+    if (!Array.isArray(uploaded))
+        return pointer;
+    const entry = uploaded.find((candidate) => {
+        if (!candidate || typeof candidate !== "object")
+            return false;
+        return (candidate
+            .raw_evidence_pointer_id === pointer.raw_evidence_pointer_id);
+    });
+    if (!entry || typeof entry !== "object")
+        return pointer;
+    const record = entry;
+    return pointerWithUploadedMetadata(pointer, {
+        content_hash_sha256: typeof record["content_hash_sha256"] === "string"
+            ? record["content_hash_sha256"]
+            : undefined,
+        byte_size: typeof record["byte_size"] === "number" ? record["byte_size"] : undefined,
+        redaction: record["redaction"],
+    });
+}
+function pointerWithUploadedMetadata(pointer, metadata) {
+    const redaction = RawEvidenceRedactionMetadataSchema.safeParse(metadata.redaction);
+    return {
+        ...pointer,
+        content_hash_sha256: typeof metadata.content_hash_sha256 === "string"
+            ? metadata.content_hash_sha256
+            : pointer.content_hash_sha256,
+        byte_size: typeof metadata.byte_size === "number" ? metadata.byte_size : pointer.byte_size,
+        redaction: redaction.success ? redaction.data : pointer.redaction,
+    };
+}
 function summarizeOutcomes(outcomes, usedLegacyFallback) {
     const uploaded = outcomes.filter((outcome) => outcome.upload_state === "uploaded");
     return {

package/dist/local-state.js

@@ -21,12 +21,15 @@ export function getCollectorRuntimePaths(homeDir = os.homedir()) {
 }
 export async function installLocalCollector(options = {}) {
     const homeDir = options.homeDir ?? os.homedir();
-    const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
+    const repoRoots = normalizeRepoRoots(options.repoRoots);
+    const repoRoot = path.resolve(options.repoRoot ?? repoRoots[0] ?? process.cwd());
     const paths = getCollectorRuntimePaths(homeDir);
     await ensureRuntimeDirectories(paths);
     const existingConfig = await readLocalCollectorConfig(paths).catch(() => null);
-    const defaultRepoPaths = new Set(existingConfig?.default_repo_paths ?? []);
-    defaultRepoPaths.add(repoRoot);
+    const defaultRepoPaths = new Set(options.replaceRepoRoots ? [] : (existingConfig?.default_repo_paths ?? []));
+    for (const root of repoRoots.length > 0 ? repoRoots : [repoRoot]) {
+        defaultRepoPaths.add(root);
+    }
     const rawEvidenceUpload = existingConfig?.raw_evidence_upload === "disabled" ||
         existingConfig?.raw_evidence_upload === "remote_short_retention_opt_in"
         ? "remote_durable_opt_in"
@@ -55,6 +58,20 @@ export async function installLocalCollector(options = {}) {
         message: "Local collector installed. Pair/login is still required before remote upload.",
     };
 }
+function normalizeRepoRoots(repoRoots) {
+    if (!repoRoots)
+        return [];
+    const seen = new Set();
+    const normalized = [];
+    for (const root of repoRoots) {
+        const resolved = path.resolve(root);
+        if (seen.has(resolved))
+            continue;
+        seen.add(resolved);
+        normalized.push(resolved);
+    }
+    return normalized;
+}
 export async function pairLocalCollector(options = {}) {
     const homeDir = options.homeDir ?? os.homedir();
     const paths = getCollectorRuntimePaths(homeDir);