@indigoai-us/hq-cloud 5.35.0 → 5.36.0

package/dist/cli/share.test.js

@@ -19,6 +19,17 @@ vi.mock("../s3.js", () => ({
     deleteRemoteFile: vi.fn().mockResolvedValue(undefined),
     headRemoteFile: vi.fn().mockResolvedValue(null),
 }));
+// Mock readline so the interactive-conflict serialization test can observe
+// prompt lifecycle (createInterface + close) without ever touching stdin.
+// Default impl never resolves; conflict-prompt tests below override per-test
+// to script answers.
+vi.mock("readline", () => ({
+    createInterface: vi.fn(() => ({
+        question: vi.fn(),
+        close: vi.fn(),
+    })),
+}));
+import * as readline from "readline";
 import { share, _testing as shareTesting } from "./share.js";
 import { deleteRemoteFile, headRemoteFile, uploadFile, uploadSymlink } from "../s3.js";
 const mockConfig = {
@@ -2213,5 +2224,526 @@ describe("currency-gated: journal version 2 fixtures", () => {
         expect(result.filesDeleted).toBe(1);
         expect(deleteRemoteFile).toHaveBeenCalledWith(expect.anything(), "core/policies/old.md");
     });
+    // ── Fix #1 (5.36.0): lstat fast-path ─────────────────────────────────────
+    //
+    // When skipUnchanged is on AND the journal carries an mtimeMs for the
+    // file AND (lstat.size, lstat.mtimeMs) match the recorded values, the
+    // push planner classifies the file `unchanged` WITHOUT reading its
+    // bytes. Same trade-off rsync/gitignore use; turns no-op syncs from
+    // O(file bytes) into O(file count).
+    //
+    // We prove "the SHA256 path didn't run" by seeding the journal with an
+    // intentionally WRONG hash but matching mtimeMs+size. If the fast-path
+    // fires → file is classified `unchanged` purely on lstat (no hash
+    // compare). If the fast-path is skipped → hashFile runs, hashes the
+    // real file, fails the !== journal-hash check, and uploads. The
+    // upload-vs-skip outcome is the diagnostic signal.
+    describe("lstat fast-path (5.36.0)", () => {
+        it("skips upload when mtimeMs + size match journal (even with wrong stored hash)", async () => {
+            const companyRoot = path.join(tmpDir, "companies", "acme");
+            fs.mkdirSync(companyRoot, { recursive: true });
+            const testFile = path.join(companyRoot, "stable.md");
+            fs.writeFileSync(testFile, "stable bytes");
+            const lstat = fs.lstatSync(testFile);
+            // Intentionally-wrong hash; matching mtimeMs+size. If the fast-path
+            // doesn't fire, hashFile runs, the real hash != "sentinel-wrong-hash",
+            // and the file gets uploaded — which would fail this test.
+            const journalPath = path.join(stateDir, "sync-journal.acme.json");
+            fs.writeFileSync(journalPath, JSON.stringify({
+                version: "2",
+                lastSync: new Date().toISOString(),
+                files: {
+                    "stable.md": {
+                        hash: "sentinel-wrong-hash-fast-path-should-skip-without-checking",
+                        size: lstat.size,
+                        mtimeMs: lstat.mtimeMs,
+                        syncedAt: new Date().toISOString(),
+                        direction: "up",
+                    },
+                },
+                pulls: [],
+            }));
+            const result = await share({
+                paths: [testFile],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                skipUnchanged: true,
+            });
+            // Fast-path fired → no hash read → no upload despite wrong stored hash.
+            expect(result.filesUploaded).toBe(0);
+            expect(result.filesSkipped).toBe(1);
+            expect(uploadFile).not.toHaveBeenCalled();
+        });
+        it("uploads when mtime changes (fast-path misses → hash runs → mismatch)", async () => {
+            const companyRoot = path.join(tmpDir, "companies", "acme");
+            fs.mkdirSync(companyRoot, { recursive: true });
+            const testFile = path.join(companyRoot, "touched.md");
+            fs.writeFileSync(testFile, "original bytes!");
+            const originalLstat = fs.lstatSync(testFile);
+            // Wrong hash + matching mtimeMs+size — would skip via fast-path if
+            // mtime stayed the same. We're about to bump mtime, so fast-path
+            // MUST miss, hashFile MUST run, hash MUST mismatch the wrong stored
+            // value, and the file MUST upload.
+            const journalPath = path.join(stateDir, "sync-journal.acme.json");
+            fs.writeFileSync(journalPath, JSON.stringify({
+                version: "2",
+                lastSync: new Date().toISOString(),
+                files: {
+                    "touched.md": {
+                        hash: "sentinel-wrong-hash-mtime-bump-forces-hashFile-run",
+                        size: originalLstat.size,
+                        mtimeMs: originalLstat.mtimeMs,
+                        syncedAt: new Date().toISOString(),
+                        direction: "up",
+                    },
+                },
+                pulls: [],
+            }));
+            // Bump mtime forward — fast-path comparison mtime fails.
+            const futureTime = new Date(Date.now() + 60_000);
+            fs.utimesSync(testFile, futureTime, futureTime);
+            const result = await share({
+                paths: [testFile],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                skipUnchanged: true,
+            });
+            // Fast-path missed → second-stage hash compare ran → wrong stored hash
+            // forced the upload.
+            expect(result.filesUploaded).toBe(1);
+            expect(uploadFile).toHaveBeenCalled();
+        });
+        it("stamps mtimeMs on the journal entry after a successful upload", async () => {
+            const companyRoot = path.join(tmpDir, "companies", "acme");
+            fs.mkdirSync(companyRoot, { recursive: true });
+            const testFile = path.join(companyRoot, "fresh.md");
+            fs.writeFileSync(testFile, "fresh content");
+            const lstat = fs.lstatSync(testFile);
+            const result = await share({
+                paths: [testFile],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+            });
+            expect(result.filesUploaded).toBe(1);
+            const journalPath = path.join(stateDir, "sync-journal.acme.json");
+            const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+            expect(journal.files["fresh.md"]).toBeDefined();
+            expect(journal.files["fresh.md"].mtimeMs).toBe(lstat.mtimeMs);
+            expect(journal.files["fresh.md"].size).toBe(lstat.size);
+        });
+        it("falls through to hashFile when journal has no mtimeMs (pre-5.36 entry)", async () => {
+            // Back-compat: pre-5.36 journals don't carry mtimeMs. The first sync
+            // after upgrade must fall through to the hash path so legacy entries
+            // still work; the post-upload stamp adds the field so subsequent
+            // syncs use the fast-path.
+            const companyRoot = path.join(tmpDir, "companies", "acme");
+            fs.mkdirSync(companyRoot, { recursive: true });
+            const testFile = path.join(companyRoot, "legacy.md");
+            fs.writeFileSync(testFile, "legacy bytes");
+            const { hashFile: realHashFile } = await import("../journal.js");
+            const realHash = realHashFile(testFile);
+            const realSize = fs.statSync(testFile).size;
+            // Real hash but NO mtimeMs — must take hash path. Hash matches →
+            // second-stage compare skips upload.
+            const journalPath = path.join(stateDir, "sync-journal.acme.json");
+            fs.writeFileSync(journalPath, JSON.stringify({
+                version: "1",
+                lastSync: new Date().toISOString(),
+                files: {
+                    "legacy.md": {
+                        hash: realHash,
+                        size: realSize,
+                        syncedAt: new Date().toISOString(),
+                        direction: "up",
+                        // No mtimeMs — pre-5.36 shape.
+                    },
+                },
+            }));
+            const result = await share({
+                paths: [testFile],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                skipUnchanged: true,
+            });
+            // Pre-5.36 entry → fast-path skipped → hash path ran → real hash
+            // matched → upload skipped at second stage. Same outcome as 5.35.0.
+            expect(result.filesSkipped).toBe(1);
+            expect(uploadFile).not.toHaveBeenCalled();
+            // And the upgrade path: a follow-up upload (forced by changing the
+            // file) must stamp mtimeMs so the NEXT sync gets the fast-path.
+            // Verified separately by the "stamps mtimeMs" test above.
+        });
+    });
+    // ── Fix #2 (5.36.0): bounded-parallel transfer pool ──────────────────────
+    //
+    // Replaces the serial PUT loop with a bounded-concurrent pool (default 16,
+    // env-tunable via HQ_SYNC_TRANSFER_CONCURRENCY). Per-file progress events
+    // still fire (now at file-settle time, not plan-walk time) so the menubar
+    // stream parser sees the same shape. Aborts mid-batch let in-flight PUTs
+    // finish but stop queueing new ones.
+    describe("parallel upload pool (5.36.0)", () => {
+        it("runs uploads with measurable parallelism (8+ in flight before first settles)", async () => {
+            const companyRoot = path.join(tmpDir, "companies", "acme");
+            fs.mkdirSync(companyRoot, { recursive: true });
+            // Plan 32 files so the pool of 16 has clear evidence of parallelism.
+            const FILE_COUNT = 32;
+            for (let i = 0; i < FILE_COUNT; i++) {
+                fs.writeFileSync(path.join(companyRoot, `file-${i.toString().padStart(2, "0")}.bin`), `content-${i}`);
+            }
+            // Instrument uploadFile to record start + end timestamps and
+            // artificially delay each PUT by 50ms. Serial would be ~1600ms;
+            // pool of 16 should be ~100ms (two waves of 16).
+            const UPLOAD_DELAY_MS = 50;
+            const startTimes = [];
+            const endTimes = [];
+            vi.mocked(uploadFile).mockImplementation(async (_ctx, _abs, key) => {
+                startTimes.push({ key, t: Date.now() });
+                await new Promise((r) => setTimeout(r, UPLOAD_DELAY_MS));
+                endTimes.push({ key, t: Date.now() });
+                return { etag: '"upload-etag"' };
+            });
+            const events = [];
+            const result = await share({
+                paths: [companyRoot],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                onEvent: (e) => events.push(e),
+                // onConflict must be set so the pool uses its env-tunable
+                // concurrency (Codex P1 fix forces concurrency=1 in interactive
+                // mode to serialize readline prompts).
+                onConflict: "keep",
+            });
+            expect(result.filesUploaded).toBe(FILE_COUNT);
+            expect(uploadFile).toHaveBeenCalledTimes(FILE_COUNT);
+            // Parallelism check #1: by the time the 8th PUT *started*, the 1st
+            // PUT had NOT yet ended. (Stronger than just "wall-clock fast" —
+            // proves true overlap.)
+            expect(startTimes.length).toBeGreaterThanOrEqual(8);
+            const eighthStart = startTimes[7].t;
+            const firstEnd = endTimes[0]?.t ?? Number.POSITIVE_INFINITY;
+            expect(eighthStart).toBeLessThan(firstEnd);
+            // Parallelism check #2: at least 8 PUTs were in flight simultaneously
+            // at some point.
+            let maxConcurrent = 0;
+            const sortedEvents = [];
+            for (const s of startTimes)
+                sortedEvents.push({ t: s.t, kind: "start" });
+            for (const e of endTimes)
+                sortedEvents.push({ t: e.t, kind: "end" });
+            // Equal-t ordering: starts before ends gives an upper bound. For the
+            // lower-bound assertion below (>= 8) this is conservative-safe.
+            sortedEvents.sort((a, b) => a.t - b.t || (a.kind === "start" ? -1 : 1));
+            let cur = 0;
+            for (const ev of sortedEvents) {
+                if (ev.kind === "start") {
+                    cur++;
+                    if (cur > maxConcurrent)
+                        maxConcurrent = cur;
+                }
+                else {
+                    cur--;
+                }
+            }
+            expect(maxConcurrent).toBeGreaterThanOrEqual(8);
+            // Event-count correctness: one progress event per file.
+            const progressEvents = events.filter((e) => !!e && typeof e === "object" && e.type === "progress");
+            expect(progressEvents.length).toBe(FILE_COUNT);
+            const progressKeys = new Set(progressEvents.map((e) => e.path));
+            expect(progressKeys.size).toBe(FILE_COUNT);
+        });
+        it("HQ_SYNC_TRANSFER_CONCURRENCY env var caps the pool size", async () => {
+            const companyRoot = path.join(tmpDir, "companies", "acme");
+            fs.mkdirSync(companyRoot, { recursive: true });
+            for (let i = 0; i < 10; i++) {
+                fs.writeFileSync(path.join(companyRoot, `f-${i}.bin`), `c-${i}`);
+            }
+            process.env.HQ_SYNC_TRANSFER_CONCURRENCY = "2";
+            const startTimes = [];
+            const endTimes = [];
+            vi.mocked(uploadFile).mockImplementation(async () => {
+                startTimes.push(Date.now());
+                await new Promise((r) => setTimeout(r, 30));
+                endTimes.push(Date.now());
+                return { etag: '"upload-etag"' };
+            });
+            try {
+                await share({
+                    paths: [companyRoot],
+                    company: "acme",
+                    vaultConfig: mockConfig,
+                    hqRoot: tmpDir,
+                    // Force non-interactive mode so the pool honors the env cap
+                    // (interactive mode forces concurrency=1 — see Codex P1 fix).
+                    onConflict: "keep",
+                });
+                // Compute max concurrency from start/end timeline. With cap=2,
+                // we should never see more than 2 in flight. Date.now() has only
+                // ms granularity so simultaneous start/end timestamps are common;
+                // process ENDs before STARTs at the same ms (the actual ordering
+                // — a task can't start until the prior one's `finally` removed it
+                // from inFlight).
+                const sortedEvents = [];
+                for (const t of startTimes)
+                    sortedEvents.push({ t, kind: "start" });
+                for (const t of endTimes)
+                    sortedEvents.push({ t, kind: "end" });
+                sortedEvents.sort((a, b) => a.t - b.t || (a.kind === "end" ? -1 : 1));
+                let cur = 0;
+                let maxConcurrent = 0;
+                for (const ev of sortedEvents) {
+                    if (ev.kind === "start") {
+                        cur++;
+                        if (cur > maxConcurrent)
+                            maxConcurrent = cur;
+                    }
+                    else {
+                        cur--;
+                    }
+                }
+                expect(maxConcurrent).toBeLessThanOrEqual(2);
+            }
+            finally {
+                delete process.env.HQ_SYNC_TRANSFER_CONCURRENCY;
+            }
+        });
+        it("one failed upload does not abort sibling uploads in the pool", async () => {
+            const companyRoot = path.join(tmpDir, "companies", "acme");
+            fs.mkdirSync(companyRoot, { recursive: true });
+            for (let i = 0; i < 6; i++) {
+                fs.writeFileSync(path.join(companyRoot, `f-${i}.bin`), `c-${i}`);
+            }
+            // One file fails; others succeed.
+            vi.mocked(uploadFile).mockImplementation(async (_ctx, _abs, key) => {
+                if (key === "f-2.bin")
+                    throw new Error("simulated upload failure");
+                return { etag: '"upload-etag"' };
+            });
+            const events = [];
+            const result = await share({
+                paths: [companyRoot],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                onEvent: (e) => events.push(e),
+                // Non-interactive so the pool runs in parallel (Codex P1 fix).
+                onConflict: "keep",
+            });
+            // 5 succeeded + 1 errored.
+            expect(result.filesUploaded).toBe(5);
+            const errorEvents = events.filter((e) => !!e && typeof e === "object" && e.type === "error");
+            expect(errorEvents.length).toBe(1);
+            expect(errorEvents[0].path).toBe("f-2.bin");
+        });
+        // ── Codex P1 (5.36.x): interactive conflict prompt serialization ────
+        //
+        // The parallel pool can run multiple processUploadItem workers
+        // concurrently; each worker calls resolveConflict() on a conflict, and
+        // in interactive mode (onConflict === undefined) that opens a readline
+        // prompt on process.stdin. Two prompts open at once would race for the
+        // same terminal input — answers would interleave nondeterministically.
+        //
+        // Trade-off (Option A): when onConflict is undefined we force pool
+        // concurrency to 1 for the whole run. Interactive sessions are rare
+        // (operator is already at the terminal clicking through prompts), so
+        // serializing the entire pool is acceptable and has the smallest
+        // blast radius vs. a per-prompt mutex. Non-interactive (onConflict set)
+        // keeps full parallelism.
+        it("serializes interactive conflict prompts (no two readline prompts open at once)", async () => {
+            const companyRoot = path.join(tmpDir, "companies", "acme");
+            fs.mkdirSync(companyRoot, { recursive: true });
+            // Two files that will both trigger a fresh-collision conflict —
+            // remote already has them (different bytes) and there's no journal
+            // entry yet, so the push planner classifies as a conflict.
+            fs.writeFileSync(path.join(companyRoot, "a.bin"), "local-a");
+            fs.writeFileSync(path.join(companyRoot, "b.bin"), "local-b");
+            // headRemoteFile returns a remote with a non-matching MD5 (the local
+            // body hashes differently), forcing the fresh-collision branch.
+            vi.mocked(headRemoteFile).mockResolvedValue({
+                etag: '"deadbeefdeadbeefdeadbeefdeadbeef"',
+                lastModified: new Date(Date.now() - 60_000),
+                size: 999,
+                metadata: {},
+            });
+            // Track prompt lifecycle: each createInterface increments openCount;
+            // each close decrements. If concurrency leaks, openCount will exceed
+            // 1 between question() and close().
+            let openCount = 0;
+            let maxOpenAtOnce = 0;
+            const promptOrder = [];
+            vi.mocked(readline.createInterface).mockImplementation(() => {
+                openCount++;
+                if (openCount > maxOpenAtOnce)
+                    maxOpenAtOnce = openCount;
+                promptOrder.push("open");
+                return {
+                    question: (_q, cb) => {
+                        // Yield a tick so any other concurrent worker that *was* going
+                        // to open a prompt would do so before we answer + close.
+                        setTimeout(() => cb("k"), 25);
+                    },
+                    close: () => {
+                        openCount--;
+                        promptOrder.push("close");
+                    },
+                };
+            });
+            const result = await share({
+                paths: [companyRoot],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                // onConflict intentionally omitted → interactive mode
+            });
+            // Both conflicts surfaced.
+            expect(result.conflictPaths.length).toBe(2);
+            // Both prompts opened (one per conflicting file).
+            expect(readline.createInterface).toHaveBeenCalledTimes(2);
+            // CRITICAL: no two prompts open simultaneously.
+            expect(maxOpenAtOnce).toBe(1);
+            // CRITICAL: strict open → close → open → close ordering.
+            expect(promptOrder).toEqual(["open", "close", "open", "close"]);
+        });
+        it("parallel pool stays at full concurrency when onConflict is set", async () => {
+            // Sanity check: the interactive-mode fallback to concurrency=1 must
+            // NOT regress non-interactive throughput. With onConflict provided
+            // (no readline involved) the pool keeps the 16-wide default.
+            const companyRoot = path.join(tmpDir, "companies", "acme");
+            fs.mkdirSync(companyRoot, { recursive: true });
+            const FILE_COUNT = 16;
+            for (let i = 0; i < FILE_COUNT; i++) {
+                fs.writeFileSync(path.join(companyRoot, `f-${i.toString().padStart(2, "0")}.bin`), `c-${i}`);
+            }
+            const startTimes = [];
+            const endTimes = [];
+            vi.mocked(uploadFile).mockImplementation(async () => {
+                startTimes.push(Date.now());
+                await new Promise((r) => setTimeout(r, 30));
+                endTimes.push(Date.now());
+                return { etag: '"upload-etag"' };
+            });
+            await share({
+                paths: [companyRoot],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                onConflict: "keep",
+            });
+            // Compute max concurrency from start/end timeline.
+            const sortedEvents = [];
+            for (const t of startTimes)
+                sortedEvents.push({ t, kind: "start" });
+            for (const t of endTimes)
+                sortedEvents.push({ t, kind: "end" });
+            sortedEvents.sort((a, b) => a.t - b.t || (a.kind === "start" ? -1 : 1));
+            let cur = 0;
+            let maxConcurrent = 0;
+            for (const ev of sortedEvents) {
+                if (ev.kind === "start") {
+                    cur++;
+                    if (cur > maxConcurrent)
+                        maxConcurrent = cur;
+                }
+                else {
+                    cur--;
+                }
+            }
+            // Should be significantly > 1 (full pool); use 4 as a conservative
+            // lower bound so the test isn't flaky on slow CI.
+            expect(maxConcurrent).toBeGreaterThanOrEqual(4);
+        });
+        // ── Codex P1 (5.36.x): pool drains in-flight on worker rejection ────
+        //
+        // Pre-fix: the scheduler waited on `Promise.race(inFlight)`. If any
+        // worker rejected (e.g. headRemoteFile threw before its caller's
+        // try/catch was reached), the race rejected immediately, the await
+        // unwound out of the pool, and remaining in-flight workers kept
+        // running — their PUTs still mutated S3 while share() had already
+        // failed and skipped writeJournal. Remote and journal drifted out
+        // of sync, breaking the next run's planner.
+        //
+        // Fix: wrap each worker so it never rejects from the pool's
+        // perspective; collect errors in a side array; after the pool drains
+        // (queue empty + inFlight empty), if errors exist, throw an
+        // aggregated error so the caller still sees the failure.
+        it("drains all in-flight uploads before throwing when a worker rejects (headRemoteFile)", async () => {
+            const companyRoot = path.join(tmpDir, "companies", "acme");
+            fs.mkdirSync(companyRoot, { recursive: true });
+            const FILE_COUNT = 10;
+            for (let i = 0; i < FILE_COUNT; i++) {
+                fs.writeFileSync(path.join(companyRoot, `f-${i.toString().padStart(2, "0")}.bin`), `content-${i}`);
+            }
+            // headRemoteFile throws on file index 3 (an unhandled-by-pool
+            // rejection — the surrounding try/catch in processUploadItem
+            // covers uploadFile but NOT headRemoteFile). All other files
+            // resolve to null (no remote → straight upload). Each call takes
+            // ~50ms so multiple workers are in flight when the rejection
+            // surfaces.
+            vi.mocked(headRemoteFile).mockImplementation(async (_ctx, key) => {
+                await new Promise((r) => setTimeout(r, 50));
+                if (key === "f-03.bin") {
+                    throw new Error("simulated headRemoteFile failure");
+                }
+                return null;
+            });
+            // Per-file uploadFile delay so there's measurable overlap with
+            // the head-rejecting worker.
+            vi.mocked(uploadFile).mockImplementation(async (_ctx, _abs, _key) => {
+                await new Promise((r) => setTimeout(r, 50));
+                return { etag: '"upload-etag"' };
+            });
+            let thrown = null;
+            try {
+                await share({
+                    paths: [companyRoot],
+                    company: "acme",
+                    vaultConfig: mockConfig,
+                    hqRoot: tmpDir,
+                    // onConflict set so the pool runs in parallel (interactive
+                    // mode forces concurrency=1 and the test wants overlap).
+                    onConflict: "keep",
+                });
+            }
+            catch (err) {
+                thrown = err;
+            }
+            // share() rejects with the worker's error surfaced.
+            expect(thrown).toBeInstanceOf(Error);
+            expect(thrown.message).toMatch(/headRemoteFile failure/);
+            // CRITICAL: headRemoteFile was called for every file — proves the
+            // pool kept scheduling work after the rejecting worker started,
+            // and (combined with the writeJournal assertion below) that the
+            // pool drained the in-flight set instead of bailing on first
+            // rejection. Pre-fix this would be < FILE_COUNT.
+            expect(headRemoteFile).toHaveBeenCalledTimes(FILE_COUNT);
+            // CRITICAL: uploadFile was called for the 9 non-rejecting files.
+            // (f-03 rejected at headRemoteFile, so its uploadFile never
+            // fires.) Pre-fix this could be < 9 because the pool would
+            // abandon in-flight workers before they reached their PUT.
+            expect(uploadFile).toHaveBeenCalledTimes(FILE_COUNT - 1);
+            // CRITICAL: writeJournal still ran — the journal on disk has
+            // entries for the 9 successful uploads. Pre-fix the journal was
+            // never written (the throw escaped before writeJournal()), so
+            // the next sync re-uploaded all 9 successful files unnecessarily
+            // AND lost the etag/mtime stamps needed by the lstat fast-path.
+            const journalPath = path.join(stateDir, "sync-journal.acme.json");
+            expect(fs.existsSync(journalPath)).toBe(true);
+            const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+            const stampedKeys = Object.keys(journal.files);
+            expect(stampedKeys.length).toBe(FILE_COUNT - 1);
+            // The failed file is NOT in the journal (no successful upload).
+            expect(stampedKeys).not.toContain("f-03.bin");
+            // The 9 successful files ARE in the journal.
+            for (let i = 0; i < FILE_COUNT; i++) {
+                if (i === 3)
+                    continue;
+                expect(stampedKeys).toContain(`f-${i.toString().padStart(2, "0")}.bin`);
+            }
+        });
+    });
 });
 //# sourceMappingURL=share.test.js.map