@bli-cockpit/cli 0.2.26 → 0.2.28

package/dist/adapters/raw-evidence.js

@@ -8,6 +8,7 @@ import { makeSourceAdapterIdentity, } from "./common.js";
 import { collectAgentImageEvidenceFromJsonlFile, } from "./agent-image-evidence.js";
 import { defaultCodexSessionDirs, } from "./codex-attribution.js";
 import { isLiveRawEvidenceSyncAttribution } from "../raw-evidence-attribution-policy.js";
+import { contentKeyedRawEvidencePackId, DELIVERY_BACKOFF_HOLDING_REASON, evidenceSourceKey, heldSourceKeys, readRawEvidenceStagingState, recordStagedObject, resolveStagedObject, writeRawEvidenceStagingState, } from "../raw-evidence-staging.js";
 const DEFAULT_SINCE_MINUTES = 24 * 60;
 const DEFAULT_SESSION_LIMIT = 50;
 const MAX_GIT_DIFF_BYTES = 2 * 1024 * 1024;
@@ -23,9 +24,14 @@ export const RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET = 300;
 const CLAUDE_MAX_COLLECT_FILE_BYTES = RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES;
 export async function collectRawEvidencePack(context, options) {
     const startedAt = context.now.toISOString();
-    const packId = rawEvidencePackId(context);
-    const evidenceDir = path.join(options.stateDir, "raw-evidence", packId);
-    const filesDir = path.join(evidenceDir, "files");
+    const rawEvidenceRoot = path.join(options.stateDir, "raw-evidence");
+    // Staging first, promotion second (BLI-3066). The pack id cannot be known
+    // until the content is, so bytes land in a private staging directory and the
+    // directory is then renamed to its content-keyed name — or dropped, when an
+    // identical pack is already there.
+    const stagingDir = path.join(rawEvidenceRoot, `.staging-${process.pid}-${crypto.randomUUID().slice(0, 8)}`);
+    const filesDir = path.join(stagingDir, "files");
+    const staging = await readRawEvidenceStagingState(options.stateDir);
     const entries = [];
     const skipped = [];
     const truncated = [];
@@ -39,7 +45,13 @@ export async function collectRawEvidencePack(context, options) {
     const collection = {
         context,
         filesDir,
-        packId,
+        rawEvidenceRoot,
+        packId: "",
+        staging,
+        heldSources: heldSourceKeys(staging, context.now),
+        stagedReusedCount: 0,
+        stagedNewCount: 0,
+        deliveryHeldCount: 0,
         entries,
         skipped,
         truncated,
@@ -101,7 +113,7 @@ export async function collectRawEvidencePack(context, options) {
         index: { value: 0 },
     };
     try {
-        await ensurePrivateDir(evidenceDir);
+        await ensurePrivateDir(stagingDir);
         await ensurePrivateDir(filesDir);
         recordAttributionCompleteness(collection, {
             codex: options.codexAttributionScan,
@@ -125,6 +137,16 @@ export async function collectRawEvidencePack(context, options) {
         const deferredByteBudgetCount = skipped.filter((entry) => entry.reason === "deferred_byte_budget").reduce((sum, entry) => sum + evidenceEntryCount(entry), 0);
         const deferredObjectBudgetCount = skipped.filter((entry) => entry.reason === "deferred_object_budget").reduce((sum, entry) => sum + evidenceEntryCount(entry), 0);
         if (entries.length === 0) {
+            // Nothing collected: drop the staging directory instead of leaving an
+            // empty pack behind. This used to leave one empty `work-*` dir per sync.
+            await fs.rm(stagingDir, { recursive: true, force: true }).catch(() => undefined);
+            const packId = contentKeyedRawEvidencePackId({
+                workContextId: context.workContextId,
+                contentHashes: [],
+            });
+            collection.packId = packId;
+            const evidenceDir = path.join(rawEvidenceRoot, packId);
+            await persistStagingState(options.stateDir, collection);
             const evidenceCompleteness = makeEvidenceCompleteness(collection, {
                 startedAt,
                 finishedAt: context.now.toISOString(),
@@ -140,6 +162,10 @@ export async function collectRawEvidencePack(context, options) {
                 skipped_count: countEvidenceEntries(skipped),
                 sanitized_count: redacted.length,
                 reused_count: reused.length,
+                staged_reused_count: collection.stagedReusedCount,
+                staged_new_count: collection.stagedNewCount,
+                delivery_held_count: collection.deliveryHeldCount,
+                stage_state: "empty",
                 deferred_byte_budget_count: deferredByteBudgetCount,
                 deferred_object_budget_count: deferredObjectBudgetCount,
                 content_kinds: [],
@@ -158,18 +184,45 @@ export async function collectRawEvidencePack(context, options) {
                 }),
             };
         }
-        const manifestWithoutSelf = makeManifest({
+        // The pack is named by what is in it, never by when it was made. Identical
+        // content on the next sync resolves to the identical directory, which is
+        // the whole fix for BLI-3066.
+        const packId = contentKeyedRawEvidencePackId({
+            workContextId: context.workContextId,
+            contentHashes: entries.map((entry) => entry.content_hash_sha256),
+        });
+        collection.packId = packId;
+        const promotion = await promoteStagedPack({
+            rawEvidenceRoot,
+            stagingDir,
+            packId,
+            workContextId: context.workContextId,
+            entries,
+        });
+        const evidenceDir = promotion.evidenceDir;
+        for (const entry of entries) {
+            if (!entry.staged_in_pack)
+                continue;
+            entry.local_path = path.join(evidenceDir, "files", path.basename(entry.local_path));
+            recordStagedObject(collection.staging, entry.content_hash_sha256, {
+                pack_id: packId,
+                relative_path: `files/${path.basename(entry.local_path)}`,
+                byte_size: entry.byte_size,
+                source_key: entry.source_key,
+                staged_at: context.now.toISOString(),
+            });
+        }
+        const manifestPath = path.join(evidenceDir, "manifest.json");
+        const manifestBytes = await stageManifest({
             context,
             packId,
+            manifestPath,
             entries,
             skipped,
             redacted,
             reused,
+            reusePack: promotion.state === "reused",
         });
-        const manifestPath = path.join(evidenceDir, "manifest.json");
-        const manifestBytes = Buffer.from(`${JSON.stringify(manifestWithoutSelf, null, 2)}\n`, "utf8");
-        await fs.writeFile(manifestPath, manifestBytes, { mode: 0o600 });
-        await chmodPrivate(manifestPath, 0o600);
         const manifestEntry = evidenceEntry({
             context,
             kind: "manifest",
@@ -181,6 +234,25 @@ export async function collectRawEvidencePack(context, options) {
             bytes: manifestBytes,
         });
         entries.push(manifestEntry);
+        await persistStagingState(options.stateDir, collection);
+        console.error("[raw-evidence] pack staged", JSON.stringify({
+            pack_id: packId,
+            stage_state: promotion.state,
+            reason: promotion.state === "reused"
+                ? "staged_reused"
+                : promotion.state === "restaged_incomplete"
+                    ? "restaged_incomplete"
+                    : promotion.priorPackCount > 0
+                        ? "restaged_content_changed"
+                        : "staged_new",
+            prior_pack_count: promotion.priorPackCount,
+            refilled_file_count: promotion.refilledFileCount,
+            file_count: entries.length,
+            byte_size: entries.reduce((sum, entry) => sum + entry.byte_size, 0),
+            staged_new: collection.stagedNewCount,
+            staged_reused: collection.stagedReusedCount,
+            delivery_held: collection.deliveryHeldCount,
+        }));
         const evidenceCompleteness = makeEvidenceCompleteness(collection, {
             startedAt,
             finishedAt: context.now.toISOString(),
@@ -191,6 +263,10 @@ export async function collectRawEvidencePack(context, options) {
             manifest_path: manifestPath,
             evidence_dir: evidenceDir,
             storage_bucket: RAW_EVIDENCE_BUCKET,
+            staged_reused_count: collection.stagedReusedCount,
+            staged_new_count: collection.stagedNewCount,
+            delivery_held_count: collection.deliveryHeldCount,
+            stage_state: promotion.state,
             file_count: entries.length,
             byte_size: entries.reduce((sum, entry) => sum + entry.byte_size, 0),
             skipped_count: countEvidenceEntries(skipped),
@@ -222,11 +298,28 @@ export async function collectRawEvidencePack(context, options) {
             }),
         };
     }
-    catch {
+    catch (error) {
         failed.push({
             kind: "raw_evidence",
             reason: "collection_failed",
         });
+        // Staging is per-attempt scratch: a crashed pass must not leave a partial
+        // directory behind to be counted, re-hashed or swept later.
+        await fs.rm(stagingDir, { recursive: true, force: true }).catch(() => undefined);
+        const packId = collection.packId ||
+            contentKeyedRawEvidencePackId({
+                workContextId: context.workContextId,
+                contentHashes: entries.map((entry) => entry.content_hash_sha256),
+            });
+        const evidenceDir = path.join(rawEvidenceRoot, packId);
+        console.error("[raw-evidence] pack collection failed", JSON.stringify({
+            pack_id: packId,
+            reason: "collection_failed",
+            detail: error instanceof Error ? error.name : typeof error,
+            collected_file_count: entries.length,
+            staged_new: collection.stagedNewCount,
+            staged_reused: collection.stagedReusedCount,
+        }));
         const evidenceCompleteness = makeEvidenceCompleteness(collection, {
             startedAt,
             finishedAt: context.now.toISOString(),
@@ -242,6 +335,10 @@ export async function collectRawEvidencePack(context, options) {
             skipped_count: countEvidenceEntries(skipped),
             sanitized_count: redacted.length,
             reused_count: reused.length,
+            staged_reused_count: collection.stagedReusedCount,
+            staged_new_count: collection.stagedNewCount,
+            delivery_held_count: collection.deliveryHeldCount,
+            stage_state: "empty",
             deferred_byte_budget_count: skipped
                 .filter((entry) => entry.reason === "deferred_byte_budget")
                 .reduce((sum, entry) => sum + evidenceEntryCount(entry), 0),
@@ -293,6 +390,10 @@ function makeRawEvidenceScan(options) {
             `bytes:${options.facts.byte_size}`,
             `skipped:${options.facts.skipped_count}`,
             `reused:${options.facts.reused_count}`,
+            `stage_state:${options.facts.stage_state}`,
+            `staged_new:${options.facts.staged_new_count}`,
+            `staged_reused:${options.facts.staged_reused_count}`,
+            `delivery_held:${options.facts.delivery_held_count}`,
             `completeness:${options.facts.evidence_completeness.status}`,
             `truncated:${options.facts.evidence_completeness.totals.truncated_count}`,
             `deferred:${options.facts.evidence_completeness.totals.deferred_count}`,
@@ -576,15 +677,26 @@ async function collectOneAgentImageFile(collection, options) {
     }
     collection.index.value += 1;
     const relativePath = path.join("files", `${String(collection.index.value).padStart(3, "0")}-agent-image-${contentHash.slice(0, 16)}.${options.image.extension}`);
-    const destination = path.join(collection.filesDir, path.basename(relativePath));
-    await fs.writeFile(destination, raw, { mode: 0o600 });
-    await chmodPrivate(destination, 0o600);
+    const imageSourceKey = evidenceSourceKey({
+        kind: options.kind,
+        sessionId: options.sessionId,
+        label: options.image.label,
+    });
+    const staged = await stageEvidenceBytes(collection, {
+        contentHash,
+        bytes: raw,
+        fileName: path.basename(relativePath),
+        kind: options.kind,
+        sourceKey: imageSourceKey,
+    });
     collection.entries.push(evidenceEntry({
         context: collection.context,
         kind: options.kind,
         packId: collection.packId,
-        localPath: destination,
+        localPath: staged.local_path,
         relativePath,
+        stagedInPack: staged.staged_in_pack,
+        sourceKey: imageSourceKey,
         mediaType: metadata.media_type,
         redactedSummary: "Raw image explicitly attached to an agent session, preserved in private durable storage.",
         bytes: raw,
@@ -606,6 +718,29 @@ async function collectOneEvidenceFile(collection, options) {
         ? "[REDACTED_FILE_NAME]"
         : fileName;
     const packedFileName = secretLikeFileName ? "redacted-file.jsonl" : fileName;
+    const sourceKey = evidenceSourceKey({
+        kind: options.kind,
+        sessionId: options.sessionId,
+        sourcePath: options.filePath,
+    });
+    // Delivery backoff is checked BEFORE the file is read. An object whose commit
+    // has failed repeatedly costs nothing at all this cycle — no read, no hash,
+    // no copy, no request — and the hold is a named, retryable gap so a held
+    // session cannot make the sync look clean (BLI-3066).
+    if (collection.heldSources.has(sourceKey)) {
+        collection.deliveryHeldCount += 1;
+        collection.skipped.push({
+            kind: options.kind,
+            label: evidenceLabel,
+            reason: DELIVERY_BACKOFF_HOLDING_REASON,
+        });
+        console.error("[raw-evidence] delivery backoff holding source", JSON.stringify({
+            reason: DELIVERY_BACKOFF_HOLDING_REASON,
+            kind: options.kind,
+            source_key: sourceKey,
+        }));
+        return false;
+    }
     if (options.maxFileBytes) {
         let stat;
         try {
@@ -694,14 +829,18 @@ async function collectOneEvidenceFile(collection, options) {
     }
     collection.index.value += 1;
     const relativePath = path.join("files", `${String(collection.index.value).padStart(3, "0")}-${shortHash(options.filePath)}-${packedFileName}`);
-    const destination = path.join(collection.filesDir, path.basename(relativePath));
-    await fs.writeFile(destination, evidenceBytes, { mode: 0o600 });
-    await chmodPrivate(destination, 0o600);
+    const staged = await stageEvidenceBytes(collection, {
+        contentHash,
+        bytes: evidenceBytes,
+        fileName: path.basename(relativePath),
+        kind: options.kind,
+        sourceKey,
+    });
     collection.entries.push(evidenceEntry({
         context: collection.context,
         kind: options.kind,
         packId: collection.packId,
-        localPath: destination,
+        localPath: staged.local_path,
         relativePath,
         mediaType: options.mediaType,
         redactedSummary: redaction
@@ -711,9 +850,38 @@ async function collectOneEvidenceFile(collection, options) {
         bytes: evidenceBytes,
         codexSessionId: options.sessionId,
         contentAddress: options.contentAddress(contentHash.slice(0, 16)),
+        stagedInPack: staged.staged_in_pack,
+        sourceKey,
     }));
     return true;
 }
+/**
+ * Put these bytes on disk once.
+ *
+ * If an earlier sync already staged this exact content and the copy is still
+ * there, that copy is used — the uploader only needs a readable path, and it
+ * does not care which pack directory holds it. This is the branch that stops
+ * one 334 MB rollout from becoming 559 copies while its commit keeps failing.
+ */
+async function stageEvidenceBytes(collection, options) {
+    const existing = await resolveStagedObject(collection.rawEvidenceRoot, collection.staging, options.contentHash);
+    if (existing) {
+        collection.stagedReusedCount += 1;
+        console.error("[raw-evidence] staged copy reused", JSON.stringify({
+            reason: "staged_reused",
+            kind: options.kind,
+            content_hash_prefix: options.contentHash.slice(0, 16),
+            byte_size: existing.entry.byte_size,
+            pack_id: existing.entry.pack_id,
+        }));
+        return { local_path: existing.local_path, staged_in_pack: false };
+    }
+    const destination = path.join(collection.filesDir, options.fileName);
+    await fs.writeFile(destination, options.bytes, { mode: 0o600 });
+    await chmodPrivate(destination, 0o600);
+    collection.stagedNewCount += 1;
+    return { local_path: destination, staged_in_pack: true };
+}
 /**
  * Decrements the per-sync budget when a file fits, or returns a deferred-skip
  * reason when it does not. The object budget bounds request count; the byte
@@ -934,15 +1102,26 @@ async function collectGitDiffFiles(collection, repoRoot) {
             continue;
         }
         const relativePath = path.join("files", `git-${target.label}.diff`);
-        const destination = path.join(collection.filesDir, path.basename(relativePath));
-        await fs.writeFile(destination, raw, { mode: 0o600 });
-        await chmodPrivate(destination, 0o600);
+        const diffSourceKey = evidenceSourceKey({
+            kind: "git_diff",
+            sessionId: collection.context.workContextId,
+            label: target.label,
+        });
+        const staged = await stageEvidenceBytes(collection, {
+            contentHash,
+            bytes: raw,
+            fileName: path.basename(relativePath),
+            kind: "git_diff",
+            sourceKey: diffSourceKey,
+        });
         collection.entries.push(evidenceEntry({
             context: collection.context,
             kind: "git_diff",
             packId: collection.packId,
-            localPath: destination,
+            localPath: staged.local_path,
             relativePath,
+            stagedInPack: staged.staged_in_pack,
+            sourceKey: diffSourceKey,
             mediaType: "text/x-diff",
             redactedSummary: redaction
                 ? `Raw git ${target.label} diff preserved locally with env/secret paths excluded and secret-like values deterministically redacted.`
@@ -1309,6 +1488,8 @@ function evidenceEntry(options) {
         redacted_summary: options.redactedSummary,
         ...(options.redaction ? { redaction: options.redaction } : {}),
         codex_session_id: options.codexSessionId ?? null,
+        staged_in_pack: options.stagedInPack !== false,
+        source_key: options.sourceKey ?? null,
         ...(options.artifactMetadata
             ? {
                 artifact_metadata: {
@@ -1323,6 +1504,10 @@ function evidenceEntry(options) {
             : {}),
     };
 }
+// `local_path` is redacted out, and so are the staging bookkeeping fields:
+// where a copy happens to live on this disk is not part of the pack's identity,
+// and putting it in the manifest would make byte-identical content produce
+// different manifests.
 function redactManifestEntry(entry) {
     return {
         kind: entry.kind,
@@ -1417,13 +1602,125 @@ function readableKeySegment(value, fallback, options = {}) {
 function posixPath(parts) {
     return parts.join("/").replace(/\\/g, "/").replace(/\/+/g, "/");
 }
-function rawEvidencePackId(context) {
-    const material = [
-        context.workContextId,
-        context.sessionId,
-        context.now.toISOString(),
-    ].join(":");
-    return `${context.workContextId}-${shortHash(material)}`;
+/**
+ * Turn the staging directory into the content-keyed pack directory.
+ *
+ * Three outcomes, all of them named:
+ * - the pack does not exist yet: rename staging into place (`new`);
+ * - it exists and holds every file this pass staged: adopt it and delete the
+ *   staging copy (`reused`) — nothing is copied twice;
+ * - it exists but is missing files: fill the gaps from staging
+ *   (`restaged_incomplete`), because a half-written pack must not be trusted.
+ *
+ * Never deletes an existing pack directory wholesale: another pack's entries
+ * can point into it through the staged-object index.
+ */
+async function promoteStagedPack(options) {
+    const evidenceDir = path.join(options.rawEvidenceRoot, options.packId);
+    const priorPackCount = await countPriorPacks(options.rawEvidenceRoot, options.workContextId, options.packId);
+    const existing = await fs.stat(evidenceDir).catch(() => null);
+    if (!existing?.isDirectory()) {
+        try {
+            await fs.rename(options.stagingDir, evidenceDir);
+            return {
+                state: "new",
+                evidenceDir,
+                priorPackCount,
+                refilledFileCount: 0,
+            };
+        }
+        catch {
+            // A concurrent sync can win the race to the same content-keyed name.
+            // Losing it is fine: the winner staged the identical bytes.
+        }
+    }
+    let refilledFileCount = 0;
+    await ensurePrivateDir(path.join(evidenceDir, "files"));
+    for (const entry of options.entries) {
+        if (!entry.staged_in_pack)
+            continue;
+        const fileName = path.basename(entry.local_path);
+        const target = path.join(evidenceDir, "files", fileName);
+        const info = await fs.stat(target).catch(() => null);
+        if (info?.isFile() && info.size === entry.byte_size)
+            continue;
+        await fs.copyFile(entry.local_path, target).catch(() => undefined);
+        await chmodPrivate(target, 0o600);
+        refilledFileCount += 1;
+    }
+    await fs.rm(options.stagingDir, { recursive: true, force: true }).catch(() => undefined);
+    return {
+        state: refilledFileCount > 0 ? "restaged_incomplete" : "reused",
+        evidenceDir,
+        priorPackCount,
+        refilledFileCount,
+    };
+}
+async function countPriorPacks(rawEvidenceRoot, workContextId, packId) {
+    const entries = await fs
+        .readdir(rawEvidenceRoot, { withFileTypes: true })
+        .catch(() => []);
+    return entries.filter((entry) => entry.isDirectory() &&
+        entry.name !== packId &&
+        entry.name.startsWith(`${workContextId}-`)).length;
+}
+/**
+ * Write the manifest, or keep the one already in a reused pack.
+ *
+ * Byte-stability matters here: the manifest's object key is the only key that
+ * embeds the pack id, so rewriting it with a fresh `created_at` every sync
+ * would push different bytes at the same content-addressed key forever. A
+ * reused pack whose manifest already describes exactly these files keeps it.
+ */
+async function stageManifest(options) {
+    if (options.reusePack) {
+        const existing = await fs.readFile(options.manifestPath).catch(() => null);
+        if (existing && manifestDescribesEntries(existing, options.entries)) {
+            return existing;
+        }
+    }
+    const manifestBytes = Buffer.from(`${JSON.stringify(makeManifest({
+        context: options.context,
+        packId: options.packId,
+        entries: options.entries,
+        skipped: options.skipped,
+        redacted: options.redacted,
+        reused: options.reused,
+    }), null, 2)}\n`, "utf8");
+    await fs.writeFile(options.manifestPath, manifestBytes, { mode: 0o600 });
+    await chmodPrivate(options.manifestPath, 0o600);
+    return manifestBytes;
+}
+function manifestDescribesEntries(manifestBytes, entries) {
+    try {
+        const parsed = JSON.parse(manifestBytes.toString("utf8"));
+        const recorded = (parsed.files ?? [])
+            .map((file) => typeof file.content_hash_sha256 === "string"
+            ? file.content_hash_sha256
+            : "")
+            .filter(Boolean)
+            .sort();
+        const expected = entries
+            .map((entry) => entry.content_hash_sha256)
+            .sort();
+        return (recorded.length === expected.length &&
+            recorded.every((hash, index) => hash === expected[index]));
+    }
+    catch {
+        return false;
+    }
+}
+async function persistStagingState(stateDir, collection) {
+    collection.staging.updated_at = collection.context.now.toISOString();
+    await writeRawEvidenceStagingState(stateDir, collection.staging).catch((error) => {
+        // Losing this file costs reuse and attempt counts, not evidence, so it
+        // must never fail a collection — but it must never be silent either.
+        console.error("[raw-evidence] staging state write failed", JSON.stringify({
+            reason: "staging_state_write_failed",
+            detail: error instanceof Error ? error.name : typeof error,
+            staged_count: Object.keys(collection.staging.staged).length,
+        }));
+    });
 }
 function shortHash(value) {
     return crypto.createHash("sha256").update(value, "utf8").digest("hex").slice(0, 12);

package/dist/autostart.js

@@ -226,6 +226,22 @@ async function installWindowsTask(options) {
         "-File",
         registrationPath,
     ]);
+    // BLI-2996: before this, a nonzero exit here (schtasks rejected the
+    // registration script, or Set-ScheduledTask threw) skipped straight to the
+    // return with `verified: null` and never logged anything — the doctor row
+    // said "needs repair" every run with no way to tell "the rewrite itself
+    // never ran" apart from "it ran and Windows still disagrees" (BLI-2996,
+    // Brandon's machine: same silent non-convergence under two different
+    // validator messages across CLI versions). Metadata only: exit code and
+    // whether the process produced any output, never the stderr/stdout text
+    // (it can carry the state directory or a workspace path).
+    if (created.code !== 0) {
+        console.error("[autostart] windows task repair rewrite failed", JSON.stringify({
+            task_name: WINDOWS_AUTOSTART_TASK_NAME,
+            exit_code: created.code,
+            had_output: Boolean(created.stderr.trim() || created.stdout.trim()),
+        }));
+    }
     const verified = created.code === 0
         ? await windowsTaskStatus({
             ...options,
@@ -238,6 +254,14 @@ async function installWindowsTask(options) {
         })
         : null;
     const loaded = verified?.status === "loaded";
+    // windowsTaskStatus() above already logs the needs-repair case (with the
+    // problem list) when the rewrite ran but the read-back still disagrees; log
+    // the converged branch here too, tagged as a repair outcome and by name, so
+    // "did the rewrite actually fix it this run" never depends on inferring it
+    // from a routine status log emitted for an unrelated reason.
+    if (created.code === 0 && loaded) {
+        console.error("[autostart] windows task repair converged", JSON.stringify({ task_name: WINDOWS_AUTOSTART_TASK_NAME }));
+    }
     return {
         status: "installed",
         label: AUTOSTART_LABEL,
@@ -549,10 +573,17 @@ function windowsTaskRegistrationProblems(taskXml, expected) {
         .replace(/<Exec(?:\s[^>]*)?>[\s\S]*?<\/Exec>/giu, "")
         .trim();
     const exactExecBlock = execBlocks.length === 1 && actionRemainder === "" ? execBlocks[0] : "";
-    const command = exactExecBlock
+    // Strip a wrapping quote pair defensively: every real capture we have shows
+    // Task Scheduler storing <Command> unquoted, but the writer builds the /TR
+    // executable segment with the same \"-escaped quoting it uses for the
+    // launcher argument (BLI-2598), and there is no verified capture proving
+    // schtasks' own TR-splitting heuristic always discards those quotes rather
+    // than leaving them as literal text (BLI-2996 canary-gated gap). A stray
+    // pair of quotes should never be the reason a correctly-registered task
+    // reads as broken.
+    const command = stripSurroundingQuotes(exactExecBlock
         ?.match(/<Command>\s*([^<]*?)\s*<\/Command>/iu)?.[1]
-        ?.trim() ??
-        "";
+        ?.trim() ?? "");
     const actionArguments = exactExecBlock
         .match(/<Arguments>\s*([^<]*?)\s*<\/Arguments>/iu)?.[1]
         ?.trim() ?? "";
@@ -654,16 +685,35 @@ function windowsWScriptPath(env = process.env) {
  * DESKTOP-G2UO1GK (CLI 0.2.13, 2026-08-12), where the stored value differed
  * from the expected one only by those quotes (BLI-2541).
  *
- * Compare the flags exactly, because those are ours, and compare the launcher
- * as a path, because that is what Windows normalizes. Each failure returns its
- * own reason so a repair message says which half is wrong rather than
- * "arguments differ".
+ * BLI-2996: that lesson was only ever applied to the pre-BLI-2677 `-File`
+ * action. The wscript launcher pair (`//B "<launcher>"`) has NO verified
+ * real-Windows capture — `windowlessWindowsTaskXml()` in autostart.test.ts is
+ * SYNTHETIC, built by hand-editing the one real capture we have rather than
+ * exported from a machine actually running this action. A repair that rewrites
+ * the task correctly but is judged against a guessed shape can fail forever
+ * without ever being wrong (Brandon's machine: same non-convergence under two
+ * different validator messages across two CLI versions, neither of which ever
+ * repaired anything). So this comparison is deliberately structural, not
+ * positional: tokenize the way CommandLineToArgvW groups quoted/unquoted
+ * arguments, then check flag-token-then-path-token semantically (a real path
+ * comparison, case- and quote-insensitive) instead of demanding the exact
+ * byte layout we happened to send. Whatever the wscript action's real
+ * normalization turns out to be once a canary captures it, this only fails on
+ * an actual different flag or different script — not on Windows' own
+ * reformatting.
  */
 function windowsActionArgumentProblem(actionArguments, expectedFlags, expectedLauncherPath) {
-    if (!actionArguments.startsWith(expectedFlags)) {
+    const tokens = splitWindowsArgumentTokens(actionArguments);
+    if (tokens.length === 0) {
+        return "task action names no sync launcher to run";
+    }
+    if ((tokens[0] ?? "").toUpperCase() !== expectedFlags.toUpperCase()) {
         return "task action does not run the launcher with the expected batch-mode flag";
     }
-    const launcherArgument = unquoteWindowsArgument(actionArguments.slice(expectedFlags.length));
+    if (tokens.length > 2) {
+        return "task action passes unexpected extra arguments to the sync launcher";
+    }
+    const launcherArgument = tokens[1];
     if (!launcherArgument) {
         return "task action names no sync launcher to run";
     }
@@ -672,10 +722,46 @@ function windowsActionArgumentProblem(actionArguments, expectedFlags, expectedLa
     }
     return null;
 }
-function unquoteWindowsArgument(value) {
-    const trimmed = value.trim();
-    const quoted = trimmed.match(/^"([\s\S]*)"$/u) ?? trimmed.match(/^'([\s\S]*)'$/u);
-    return (quoted?.[1] ?? trimmed).trim();
+/**
+ * Quote-aware whitespace tokenizer for an already-XML-decoded `<Arguments>`
+ * value: a `"..."` run is one token (quotes stripped, whitespace inside kept),
+ * everything else splits on whitespace. Windows paths never contain a quote
+ * character, so this does not need CommandLineToArgvW's backslash-escaping
+ * rules — only its quoting rule — to tell "one argument with a space in it"
+ * apart from "two arguments".
+ */
+function splitWindowsArgumentTokens(value) {
+    const tokens = [];
+    let current = "";
+    let inQuotes = false;
+    let hasToken = false;
+    for (const char of value) {
+        if (char === '"') {
+            inQuotes = !inQuotes;
+            hasToken = true;
+            continue;
+        }
+        if (!inQuotes && /\s/u.test(char)) {
+            if (hasToken) {
+                tokens.push(current);
+                current = "";
+                hasToken = false;
+            }
+            continue;
+        }
+        current += char;
+        hasToken = true;
+    }
+    if (hasToken)
+        tokens.push(current);
+    return tokens;
+}
+/** Removes one wrapping pair of double quotes, if present. Used only to
+ * normalize before a path comparison — never to reconstruct a shell-safe
+ * value. */
+function stripSurroundingQuotes(value) {
+    const match = value.match(/^"([\s\S]*)"$/u);
+    return match ? match[1] : value;
 }
 function sameWindowsPath(left, right) {
     if (!left || !right)