@bli-cockpit/cli 0.2.5 → 0.2.7

package/dist/local-state.js

@@ -4,8 +4,8 @@ import { readFileSync } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { resolveRepoWorktreeIdentity, stableWorktreeFingerprint, stableWorktreeRoot, } from "./repo-identity.js";
-import { normalizeCollectionRoots } from "./root-normalization.js";
+import { normalizeGitOrigin, repoFingerprintFromLocalRoot, repoFingerprintFromOrigin, repoLabelFromOrigin, resolveRepoWorktreeIdentity, stableWorktreeFingerprint, stableWorktreeRoot, } from "./repo-identity.js";
+import { isSamePath, normalizeCollectionRoots, } from "./root-normalization.js";
 import { summarizeLocalUploadSpool } from "./spool/local-spool.js";
 import { summarizeInstallEventOutbox } from "./spool/install-event-outbox.js";
 const localCollectorPackage = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
@@ -139,6 +139,20 @@ export async function logoutLocalCollector(options = {}) {
     return { removed, session_file: paths.session_file };
 }
 export async function startLocalWorkContext(options = {}) {
+    return writeLocalWorkContext(options);
+}
+/**
+ * Starts a context for a transcript-attributed sync target that does not exist
+ * in the current git inventory, such as an approved wrapper folder or a
+ * deleted repo reconstructed from transcript provenance. This internal path
+ * validates the exact target identity before writing any context state.
+ */
+export async function startLocalWorkContextForAttributedTarget(options, attributedIdentity) {
+    const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
+    const identity = await validateAttributedTargetIdentity(repoRoot, attributedIdentity);
+    return writeLocalWorkContext(options, identity);
+}
+async function writeLocalWorkContext(options, attributedIdentity) {
     if (options.activeTicketId && options.clearTicket) {
         throw new Error("--ticket and --clear-ticket cannot be combined.");
     }
@@ -152,8 +166,11 @@ export async function startLocalWorkContext(options = {}) {
         operatorId: options.operatorId,
         sessionId: options.sessionId,
     });
-    const identity = await resolveIdentityOrFallback(repoRoot, options.branch);
-    const branch = options.branch ?? identity.branch;
+    const identity = attributedIdentity ??
+        (await resolveIdentityOrFallback(repoRoot, options.branch));
+    const branch = attributedIdentity
+        ? attributedIdentity.branch
+        : (options.branch ?? identity.branch);
     const sessionId = options.sessionId ??
         (session.session_state === "missing" ? `local-${crypto.randomUUID()}` : session.session_id);
     const operatorId = options.operatorId ?? session.operator_id;
@@ -225,6 +242,55 @@ export async function startLocalWorkContext(options = {}) {
     await writeJsonFile(paths.active_work_context_file, context);
     return context;
 }
+async function validateAttributedTargetIdentity(requestedRepoRoot, identity) {
+    const canonicalRoot = await stableWorktreeRoot(requestedRepoRoot);
+    const identityRoot = await stableWorktreeRoot(identity.repo_root);
+    const identityRequestedPath = await stableWorktreeRoot(identity.requested_path);
+    if (!isSamePath(canonicalRoot, identityRoot) ||
+        !isSamePath(canonicalRoot, identityRequestedPath)) {
+        throw new Error("Attributed target identity paths do not match the requested repo root.");
+    }
+    const expectedWorktreeFingerprint = stableWorktreeFingerprint(canonicalRoot);
+    if (identity.worktree_fingerprint !== expectedWorktreeFingerprint) {
+        throw new Error("Attributed target worktree fingerprint does not match its repo root.");
+    }
+    const expectedWorktreeLabel = path.basename(canonicalRoot) || "workspace";
+    if (identity.worktree_label !== expectedWorktreeLabel) {
+        throw new Error("Attributed target worktree label does not match its repo root.");
+    }
+    if (identity.repo_origin_url) {
+        const normalizedOrigin = normalizeGitOrigin(identity.repo_origin_url);
+        if (normalizedOrigin !== identity.repo_origin_url) {
+            throw new Error("Attributed target repo origin is not normalized.");
+        }
+        if (identity.repo_fingerprint !== repoFingerprintFromOrigin(normalizedOrigin)) {
+            throw new Error("Attributed target repo fingerprint does not match its origin.");
+        }
+        if (identity.repo_label !== repoLabelFromOrigin(normalizedOrigin)) {
+            throw new Error("Attributed target repo label does not match its origin.");
+        }
+        if (identity.worktree_is_primary) {
+            throw new Error("Origin-derived attributed targets cannot claim a primary live worktree.");
+        }
+    }
+    else {
+        if (identity.repo_fingerprint !==
+            repoFingerprintFromLocalRoot(canonicalRoot)) {
+            throw new Error("Attributed target repo fingerprint does not match its local root.");
+        }
+        if (identity.repo_label !== expectedWorktreeLabel) {
+            throw new Error("Attributed target repo label does not match its local root.");
+        }
+        if (!identity.worktree_is_primary) {
+            throw new Error("Local attributed targets must use their primary local identity.");
+        }
+    }
+    return {
+        ...identity,
+        requested_path: canonicalRoot,
+        repo_root: canonicalRoot,
+    };
+}
 export async function inspectLocalCollectorStatus(options = {}) {
     const now = options.now ?? new Date();
     const homeDir = options.homeDir ?? os.homedir();
@@ -405,7 +471,7 @@ async function resolveIdentityOrFallback(repoRoot, branchOverride) {
         return branchOverride ? { ...identity, branch: branchOverride } : identity;
     }
     const repoLabel = path.basename(resolvedRoot) || "workspace";
-    const repoFingerprint = `repo-${sha256(`local:${resolvedRoot}`).slice(0, 24)}`;
+    const repoFingerprint = repoFingerprintFromLocalRoot(resolvedRoot);
     const worktreeFingerprint = stableWorktreeFingerprint(resolvedRoot);
     const branch = branchOverride ?? (await resolveGitBranch(resolvedRoot));
     return {

package/dist/onboarding-roots.js

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import { realpathSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { normalizeCollectionRoots } from "./root-normalization.js";
+import { isSamePath, normalizeCollectionRoots, } from "./root-normalization.js";
 export const COLLECTION_ROOT_REQUIRED = "collection_root_required";
 export function homeRootConsentPrompt(homeDirInput) {
     const homeDir = path.resolve(homeDirInput ?? os.homedir());
@@ -85,33 +85,53 @@ export function normalizeRoots(roots) {
     return normalizeRootsDetailed(roots).roots;
 }
 export function normalizeRootsDetailed(roots, options = {}) {
+    const pathApi = options.pathApi ?? path;
     const seen = new Set();
     const candidates = [];
     const rejected = [];
-    const homeDir = path.resolve(options.homeDir ?? os.homedir());
+    const homeDir = pathApi.resolve(options.homeDir ?? os.homedir());
+    const canonicalHomeDir = canonicalPath(homeDir, pathApi, options.realpath);
     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) {
+            const expanded = expandHomePath(candidate, homeDir, pathApi);
+            const resolved = pathApi.resolve(expanded);
+            const canonicalResolved = canonicalPath(resolved, pathApi, options.realpath);
+            if (isSamePath(resolved, pathApi.parse(resolved).root, pathApi) ||
+                isSamePath(canonicalResolved, pathApi.parse(canonicalResolved).root, pathApi)) {
                 rejected.push({ input: candidate, reason: "fs_root" });
                 continue;
             }
-            if (resolved === homeDir) {
+            if (isSamePath(resolved, homeDir, pathApi) ||
+                isSamePath(canonicalResolved, canonicalHomeDir, pathApi)) {
                 if (!options.allowHomeRoot) {
                     rejected.push({ input: candidate, reason: "home_dir" });
                     continue;
                 }
             }
-            if (seen.has(resolved))
+            const seenKey = pathApi.sep === "\\"
+                ? canonicalResolved.toLowerCase()
+                : canonicalResolved;
+            if (seen.has(seenKey))
                 continue;
-            seen.add(resolved);
+            seen.add(seenKey);
             candidates.push(resolved);
         }
     }
-    return { roots: normalizeCollectionRoots(candidates), rejected };
+    return {
+        roots: normalizeCollectionRoots(candidates, pathApi),
+        rejected,
+    };
+}
+export function expandHomePath(value, homeDir, pathApi = path) {
+    if (value === "~")
+        return pathApi.resolve(homeDir);
+    if (!/^~[\\/]/u.test(value))
+        return value;
+    const parts = value.slice(2).split(/[\\/]+/u).filter(Boolean);
+    return pathApi.resolve(homeDir, ...parts);
 }
 function splitRootInput(value) {
     return value
@@ -241,7 +261,7 @@ async function promptForDeclinedHomeRoot(options, homeDir) {
     throw new Error(`${COLLECTION_ROOT_REQUIRED}: ${HOME_ROOT_NO_FOLDER_CHOSEN_MESSAGE}`);
 }
 function resolveRootInputPath(input, homeDir, cwd) {
-    const expanded = input === "~" || input.startsWith("~/")
+    const expanded = input === "~" || /^~[\\/]/u.test(input)
         ? path.join(homeDir, input.slice(2))
         : input;
     return path.resolve(cwd, expanded);
@@ -257,17 +277,17 @@ function resolvedRoots(options, roots, source, confirmed) {
 // the home-root guard on the decline path (e.g. `~/home-link -> /Users/me`).
 // Non-existent paths (or realpath errors) fall back to the lexical resolve so
 // behavior is unchanged for the retry branch and for tests using fake homedirs.
-function canonicalPath(input) {
-    const resolved = path.resolve(input);
+function canonicalPath(input, pathApi = path, realpath = realpathSync) {
+    const resolved = pathApi.resolve(input);
     try {
-        return realpathSync(resolved);
+        return pathApi.resolve(realpath(resolved));
     }
     catch {
         return resolved;
     }
 }
 function isHomeRoot(root, homeDir) {
-    return canonicalPath(root) === canonicalPath(homeDir ?? os.homedir());
+    return isSamePath(canonicalPath(root), canonicalPath(homeDir ?? os.homedir()));
 }
 function homeRootTutorial(homeDirInput) {
     const homeDir = path.resolve(homeDirInput ?? os.homedir());
@@ -305,12 +325,17 @@ export function missingCollectionRootMessage(options = {}) {
         "  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");
+export function likelyBliRootFromCwd(cwd, pathApi = path) {
+    const root = pathApi.parse(cwd).root;
+    const parts = pathApi
+        .relative(root, cwd)
+        .split(pathApi.sep)
+        .filter(Boolean);
+    const comparableParts = pathApi.sep === "\\" ? parts.map((part) => part.toLowerCase()) : parts;
+    const index = comparableParts.lastIndexOf(pathApi.sep === "\\" ? "bli" : "BLI");
     if (index < 0)
         return null;
-    return `${path.sep}${parts.slice(0, index + 1).join(path.sep)}`;
+    return pathApi.resolve(root, ...parts.slice(0, index + 1));
 }
 async function directoryExists(dir) {
     return fs.stat(dir).then((stats) => stats.isDirectory(), () => false);

package/dist/process-runner.js

@@ -0,0 +1,103 @@
+import { execFile, spawn } from "node:child_process";
+const WINDOWS_CMD_SHIMS = new Set(["cockpit", "npm", "npx"]);
+const CMD_META_CHARS = /([()\][%!^"`<>&|;, *?])/gu;
+/**
+ * Resolves commands that npm installs as `.cmd` shims through ComSpec on
+ * Windows. Arguments are escaped before they enter cmd.exe so workspace paths
+ * cannot turn into extra shell commands.
+ */
+export function commandInvocation(command, args, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    if (platform !== "win32" || !isWindowsCmdShim(command)) {
+        return { command, args, windowsVerbatimArguments: false };
+    }
+    const comspec = env.ComSpec ?? env.COMSPEC ?? "cmd.exe";
+    return {
+        command: comspec,
+        args: ["/d", "/s", "/c", `"${windowsCmdShimLine(command, args)}"`],
+        windowsVerbatimArguments: true,
+    };
+}
+/** A fully escaped command line suitable for cmd.exe's `/c` payload. */
+export function windowsCmdShimLine(command, args) {
+    const shim = windowsShimName(command);
+    return [escapeWindowsCommand(shim), ...args.map(escapeWindowsCmdArgument)].join(" ");
+}
+export function createCapturedExecRunner(options = {}) {
+    return (command, args, runOptions) => new Promise((resolve) => {
+        const env = runOptions?.env ?? options.env ?? process.env;
+        const invocation = commandInvocation(command, args, {
+            platform: options.platform,
+            env,
+        });
+        execFile(invocation.command, invocation.args, {
+            encoding: "utf8",
+            env,
+            windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+        }, (error, stdout, stderr) => {
+            const code = error == null
+                ? 0
+                : typeof error.code === "number"
+                    ? error.code
+                    : 1;
+            resolve({
+                code,
+                stdout: stdout ?? "",
+                stderr: stderr || error?.message || "",
+            });
+        });
+    });
+}
+export function createInteractiveExecRunner(options = {}) {
+    return (command, args, runOptions) => new Promise((resolve) => {
+        const env = runOptions?.env ?? options.env ?? process.env;
+        const invocation = commandInvocation(command, args, {
+            platform: options.platform,
+            env,
+        });
+        const child = spawn(invocation.command, invocation.args, {
+            stdio: "inherit",
+            env,
+            windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+        });
+        let settled = false;
+        child.on("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve({ code: 1, stdout: "", stderr: error.message });
+        });
+        child.on("close", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve({ code: code ?? 1, stdout: "", stderr: "" });
+        });
+    });
+}
+function isWindowsCmdShim(command) {
+    const normalized = command.replace(/\\/gu, "/");
+    const basename = normalized.slice(normalized.lastIndexOf("/") + 1).toLowerCase();
+    return (basename.endsWith(".cmd") ||
+        basename.endsWith(".bat") ||
+        WINDOWS_CMD_SHIMS.has(basename));
+}
+function windowsShimName(command) {
+    return /\.(?:cmd|bat)$/iu.test(command) ? command : `${command}.cmd`;
+}
+function escapeWindowsCommand(value) {
+    return value.replace(CMD_META_CHARS, "^$1");
+}
+/**
+ * Mirrors the escaping used by mature Windows process runners for `.cmd`
+ * shims. Meta characters are escaped twice because cmd.exe parses once and the
+ * npm-generated shim parses again.
+ */
+function escapeWindowsCmdArgument(value) {
+    let escaped = value.replace(/(?=(\\+?)?)\1"/gu, '$1$1\\"');
+    escaped = escaped.replace(/(?=(\\+?)?)\1$/gu, "$1$1");
+    escaped = `"${escaped}"`;
+    escaped = escaped.replace(CMD_META_CHARS, "^$1");
+    return escaped.replace(CMD_META_CHARS, "^$1");
+}

package/dist/raw-evidence-attribution-policy.js

@@ -0,0 +1,25 @@
+/**
+ * Historical backfill and attribution diagnostics may retain any deterministic
+ * fallback that produced a worktree identity. Ambiguous and unattributed
+ * sessions still need a separate quarantine lane so collection does not invent
+ * repo provenance.
+ */
+export function isRawEvidenceUploadableAttributionState(state) {
+    return state === "attributed" || state === "attributed_fallback";
+}
+const LIVE_WORKTREE_FALLBACK_REASONS = new Set([
+    "known_repo_primary_fallback",
+    "single_repo_folder_fallback",
+    "multi_repo_folder_workspace",
+    "transcript_origin_fallback",
+]);
+/**
+ * Continuous sync transports exact attribution plus the explicit fallback
+ * identities it knows how to validate and materialize as sync targets. Future
+ * fallback reasons stay fail-closed until their provenance contract is added.
+ */
+export function isLiveRawEvidenceSyncAttribution(state, reason) {
+    return (state === "attributed" ||
+        (state === "attributed_fallback" &&
+            LIVE_WORKTREE_FALLBACK_REASONS.has(reason)));
+}

package/dist/repo-identity.js

@@ -3,6 +3,7 @@ import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
+import { containsPath, isCodexWorktreePath } from "./root-normalization.js";
 const execFileAsync = promisify(execFile);
 const SKIPPED_DIR_NAMES = new Set([
     ".cache",
@@ -51,19 +52,33 @@ export async function resolveRepoWorktreeIdentity(repoRoot) {
     };
 }
 export async function discoverGitWorktrees(root, options = {}) {
+    return (await discoverGitWorktreesWithStatus(root, options)).worktrees;
+}
+/**
+ * Discovers worktrees while retaining whether traversal limits could have
+ * hidden additional repositories. Callers that make collection-completeness
+ * claims must use this result instead of treating a truncated list as whole.
+ */
+export async function discoverGitWorktreesWithStatus(root, options = {}) {
     const resolvedRoot = path.resolve(root);
-    const maxWorktrees = options.maxWorktrees ?? 50;
+    const allowedRoots = [await stableWorktreeRoot(resolvedRoot)];
+    const maxWorktrees = Math.max(1, options.maxWorktrees ?? 50);
     const direct = await resolveRepoWorktreeIdentity(resolvedRoot).catch(() => null);
     if (direct)
-        return expandLinkedWorktrees([direct], maxWorktrees);
+        return expandLinkedWorktrees([direct], maxWorktrees, allowedRoots);
     if (await hasGitMarker(resolvedRoot)) {
-        return expandLinkedWorktrees([await fallbackFilesystemIdentity(resolvedRoot)], maxWorktrees);
+        return expandLinkedWorktrees([await fallbackFilesystemIdentity(resolvedRoot)], maxWorktrees, allowedRoots);
     }
     const maxDepth = options.maxDepth ?? 2;
     const discovered = new Map();
     const stack = [{ dir: resolvedRoot, depth: 0 }];
     const visited = new Set();
-    while (stack.length > 0 && discovered.size < maxWorktrees) {
+    const incompleteReasons = new Set();
+    while (stack.length > 0) {
+        if (discovered.size >= maxWorktrees) {
+            incompleteReasons.add("max_worktrees_reached");
+            break;
+        }
         const current = stack.shift();
         if (!current)
             continue;
@@ -77,16 +92,85 @@ export async function discoverGitWorktrees(root, options = {}) {
             discovered.set(identity.worktree_fingerprint, identity);
             continue;
         }
-        if (current.depth >= maxDepth)
-            continue;
         const entries = await fs.readdir(current.dir, { withFileTypes: true }).catch(() => []);
+        if (current.depth >= maxDepth) {
+            if (entries.some((entry) => entry.isDirectory() && !shouldSkipDirectory(entry.name))) {
+                incompleteReasons.add("max_depth_reached");
+            }
+            continue;
+        }
         for (const entry of entries) {
             if (!entry.isDirectory() || shouldSkipDirectory(entry.name))
                 continue;
             stack.push({ dir: path.join(current.dir, entry.name), depth: current.depth + 1 });
         }
     }
-    return expandLinkedWorktrees([...discovered.values()].sort(compareIdentity), maxWorktrees);
+    const expanded = await expandLinkedWorktrees([...discovered.values()].sort(compareIdentity), maxWorktrees, allowedRoots);
+    for (const reason of expanded.incomplete_reasons) {
+        incompleteReasons.add(reason);
+    }
+    return {
+        worktrees: expanded.worktrees,
+        complete: incompleteReasons.size === 0,
+        incomplete_reasons: [...incompleteReasons].sort(),
+    };
+}
+/**
+ * Discovers and deduplicates git worktrees across the exact roots supplied by
+ * the caller. An approved root with no current git checkout intentionally
+ * contributes zero candidates: transcript attribution may still reconstruct a
+ * deleted-repo identity, while discovery itself never invents a broader or
+ * unrelated root.
+ */
+export async function discoverGitWorktreesInRoots(roots, options = {}) {
+    return (await discoverGitWorktreesInRootsWithStatus(roots, options)).worktrees;
+}
+export async function discoverGitWorktreesInRootsWithStatus(roots, options = {}) {
+    const maxWorktrees = Math.max(1, options.maxWorktrees ?? 50);
+    const discovered = new Map();
+    const incompleteReasons = new Set();
+    for (const root of roots) {
+        const result = await discoverGitWorktreesWithStatus(root, {
+            ...options,
+            maxWorktrees,
+        });
+        for (const reason of result.incomplete_reasons) {
+            incompleteReasons.add(reason);
+        }
+        for (const worktree of result.worktrees) {
+            if (discovered.size >= maxWorktrees) {
+                if (!discovered.has(worktree.worktree_fingerprint)) {
+                    incompleteReasons.add("max_worktrees_reached");
+                }
+                continue;
+            }
+            discovered.set(worktree.worktree_fingerprint, worktree);
+        }
+    }
+    return {
+        worktrees: [...discovered.values()].sort(compareIdentity),
+        complete: incompleteReasons.size === 0,
+        incomplete_reasons: [...incompleteReasons].sort(),
+    };
+}
+/**
+ * Canonicalizes existing collection roots through the filesystem so transcript
+ * paths and consent roots use the same spelling (for example `/private/var`
+ * versus the `/var` symlink on macOS). Missing roots remain resolved as typed.
+ */
+export async function canonicalizeCollectionRootPaths(roots) {
+    const canonical = await Promise.all(roots.map(stableWorktreeRoot));
+    return [...new Set(canonical)];
+}
+/**
+ * Returns the operator-entered resolved paths plus filesystem-canonical aliases.
+ * Both are needed for absent child repos because the child itself cannot be
+ * realpathed after deletion, while its transcript may retain either spelling.
+ */
+export async function collectionRootPathAliases(roots) {
+    const resolved = roots.map((root) => path.resolve(root));
+    const canonical = await canonicalizeCollectionRootPaths(resolved);
+    return [...new Set([...resolved, ...canonical])];
 }
 /**
  * Directory discovery skips dot-dirs, so Claude Code's isolation worktrees
@@ -99,28 +183,60 @@ export async function discoverGitWorktrees(root, options = {}) {
  * deepest-root tie-break (attribution-core D6) then attributes nested-worktree
  * sessions to the correct linked worktree. Benefits Codex sessions identically.
  */
-async function expandLinkedWorktrees(identities, maxWorktrees) {
+async function expandLinkedWorktrees(identities, maxWorktrees, allowedRoots) {
     const byFingerprint = new Map(identities.map((identity) => [identity.worktree_fingerprint, identity]));
-    const seenRoots = new Set(identities.map((identity) => path.resolve(identity.repo_root)));
-    for (const identity of identities) {
-        if (byFingerprint.size >= maxWorktrees)
-            break;
+    const seenRoots = new Set(identities.map((identity) => localPathKey(identity.repo_root)));
+    let maxWorktreesReached = identities.length > maxWorktrees;
+    for (const identity of identities.slice(0, maxWorktrees)) {
         // One `git worktree list` from any worktree returns every worktree of that
         // repo, so a single call per already-discovered repo covers its linked set.
         for (const worktreePath of await listLinkedWorktreePaths(identity.repo_root)) {
-            if (byFingerprint.size >= maxWorktrees)
-                break;
             const resolved = path.resolve(worktreePath);
-            if (seenRoots.has(resolved))
+            const rootKey = localPathKey(resolved);
+            if (seenRoots.has(rootKey))
                 continue;
-            seenRoots.add(resolved);
+            seenRoots.add(rootKey);
             const linked = await resolveRepoWorktreeIdentity(resolved).catch(() => null);
-            if (linked && !byFingerprint.has(linked.worktree_fingerprint)) {
-                byFingerprint.set(linked.worktree_fingerprint, linked);
+            if (!linked ||
+                byFingerprint.has(linked.worktree_fingerprint) ||
+                !isLinkedWorktreeWithinCollectionScope(linked, identities, allowedRoots)) {
+                continue;
+            }
+            if (byFingerprint.size >= maxWorktrees) {
+                maxWorktreesReached = true;
+                break;
             }
+            byFingerprint.set(linked.worktree_fingerprint, linked);
         }
     }
-    return [...byFingerprint.values()].sort(compareIdentity);
+    const worktrees = [...byFingerprint.values()]
+        .sort(compareIdentity)
+        .slice(0, maxWorktrees);
+    const incompleteReasons = maxWorktreesReached
+        ? ["max_worktrees_reached"]
+        : [];
+    return {
+        worktrees,
+        complete: incompleteReasons.length === 0,
+        incomplete_reasons: incompleteReasons,
+    };
+}
+function isLinkedWorktreeWithinCollectionScope(linked, discoveredFromApprovedRoots, allowedRoots) {
+    if (allowedRoots.some((root) => containsPath(root, linked.repo_root))) {
+        return true;
+    }
+    // Codex isolation worktrees live under ~/.codex/worktrees, outside the
+    // approved workspace parent. They remain in scope only when Git proves they
+    // belong to a clone discovered inside an approved root. Arbitrary sibling or
+    // personal linked worktrees do not inherit that consent.
+    if (!isCodexWorktreePath(linked.repo_root))
+        return false;
+    return discoveredFromApprovedRoots.some((identity) => identity.repo_fingerprint === linked.repo_fingerprint &&
+        allowedRoots.some((root) => containsPath(root, identity.repo_root)));
+}
+function localPathKey(value) {
+    const resolved = path.resolve(value);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 async function listLinkedWorktreePaths(repoRoot) {
     const porcelain = await runGit(["worktree", "list", "--porcelain"], repoRoot).catch(() => "");
@@ -158,11 +274,11 @@ export async function stableWorktreeRoot(repoRoot) {
     const resolvedRoot = path.resolve(repoRoot);
     return fs.realpath(resolvedRoot).catch(() => resolvedRoot);
 }
-export function stableWorktreeFingerprint(repoRoot) {
-    return `wt-${sha256(`worktree:${normalizeFingerprintPath(repoRoot)}`).slice(0, 24)}`;
+export function stableWorktreeFingerprint(repoRoot, pathApi = path) {
+    return `wt-${sha256(`worktree:${normalizeFingerprintPath(repoRoot, pathApi)}`).slice(0, 24)}`;
 }
-export function repoFingerprintFromLocalRoot(root) {
-    return `repo-${sha256(`local:${path.resolve(root)}`).slice(0, 24)}`;
+export function repoFingerprintFromLocalRoot(root, pathApi = path) {
+    return `repo-${sha256(`local:${normalizeFingerprintPath(root, pathApi)}`).slice(0, 24)}`;
 }
 export function repoFingerprintFromOrigin(origin) {
     const normalizedOrigin = normalizeGitOrigin(origin);
@@ -251,9 +367,9 @@ async function runGit(args, cwd) {
     });
     return stdout;
 }
-function normalizeFingerprintPath(repoRoot) {
-    const resolved = path.resolve(repoRoot);
-    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+function normalizeFingerprintPath(repoRoot, pathApi = path) {
+    const resolved = pathApi.resolve(repoRoot);
+    return pathApi.sep === "\\" ? resolved.toLowerCase() : resolved;
 }
 function sha256(value) {
     return crypto.createHash("sha256").update(value, "utf8").digest("hex");

package/dist/root-normalization.js

@@ -1,12 +1,13 @@
 import path from "node:path";
-export function collapseAncestorRoots(roots) {
+export function collapseAncestorRoots(roots, pathApi = path) {
     const collapsed = [];
     for (const root of roots) {
-        const resolved = path.resolve(root);
-        if (collapsed.some((existing) => containsPath(existing, resolved)))
+        const resolved = pathApi.resolve(root);
+        if (collapsed.some((existing) => containsPath(existing, resolved, pathApi))) {
             continue;
+        }
         for (let index = collapsed.length - 1; index >= 0; index -= 1) {
-            if (containsPath(resolved, collapsed[index])) {
+            if (containsPath(resolved, collapsed[index], pathApi)) {
                 collapsed.splice(index, 1);
             }
         }
@@ -14,21 +15,33 @@ export function collapseAncestorRoots(roots) {
     }
     return collapsed;
 }
-export function normalizeCollectionRoots(roots) {
-    const collapsed = collapseAncestorRoots(roots);
-    if (!collapsed.some(isBliWorkspaceRoot))
+export function normalizeCollectionRoots(roots, pathApi = path) {
+    const collapsed = collapseAncestorRoots(roots, pathApi);
+    if (!collapsed.some((root) => isBliWorkspaceRoot(root, pathApi))) {
         return collapsed;
-    return collapsed.filter((root) => !isCodexWorktreePath(root));
+    }
+    return collapsed.filter((root) => !isCodexWorktreePath(root, pathApi));
 }
-function containsPath(parent, candidate) {
-    const relative = path.relative(parent, candidate);
+export function containsPath(parent, candidate, pathApi = path) {
+    const relative = pathApi.relative(parent, candidate);
     return (relative === "" ||
-        (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative)));
+        (!!relative &&
+            relative !== ".." &&
+            !relative.startsWith(`..${pathApi.sep}`) &&
+            !pathApi.isAbsolute(relative)));
+}
+export function isSamePath(left, right, pathApi = path) {
+    return pathApi.relative(left, right) === "";
+}
+function comparableSegment(value, pathApi) {
+    return pathApi.sep === "\\" ? value.toLowerCase() : value;
 }
-function isBliWorkspaceRoot(root) {
-    return path.basename(root) === "BLI";
+function isBliWorkspaceRoot(root, pathApi) {
+    return comparableSegment(pathApi.basename(root), pathApi) ===
+        comparableSegment("BLI", pathApi);
 }
-function isCodexWorktreePath(root) {
-    const parts = root.split(path.sep).filter(Boolean);
-    return parts.some((part, index) => part === ".codex" && parts[index + 1] === "worktrees");
+export function isCodexWorktreePath(root, pathApi = path) {
+    const parts = root.split(pathApi.sep).filter(Boolean);
+    return parts.some((part, index) => comparableSegment(part, pathApi) === ".codex" &&
+        comparableSegment(parts[index + 1] ?? "", pathApi) === "worktrees");
 }