@indigoai-us/hq-cloud 6.15.79 → 6.15.81

package/dist/cli/share.test.js

@@ -17,30 +17,40 @@ vi.mock("fs", async (importOriginal) => {
 // response shape is `{ ETag: '"<hex>"' }`. uploadSymlink is the symlink-
 // preserving sibling that puts a zero-byte object with target metadata
 // instead of dereferencing the link.
-vi.mock("../s3.js", () => ({
-    toPosixKey: (key) => key.split("\\").join("/"),
-    uploadFile: vi.fn().mockResolvedValue({ etag: '"upload-etag"' }),
-    uploadSymlink: vi.fn().mockResolvedValue({ etag: '"upload-symlink-etag"' }),
-    downloadFile: vi.fn().mockResolvedValue(undefined),
-    listRemoteFiles: vi.fn().mockResolvedValue([]),
-    deleteRemoteFile: vi.fn().mockResolvedValue(undefined),
-    headRemoteFile: vi.fn().mockResolvedValue(null),
-    readVerifiedRemoteSymlinkTarget: vi.fn().mockResolvedValue(null),
-    primeObjectTransport: vi.fn().mockResolvedValue(undefined),
-    primeUploads: vi.fn().mockResolvedValue(undefined),
-    // Real exports share.ts now imports for the HQ-DESKTOP-54 privilege skip.
-    WINDOWS_SYMLINK_PRIVILEGE_REMEDY: "Enable Windows Developer Mode (Settings > Privacy & security > For developers) or run HQ sync once from an elevated terminal, then sync again.",
-    WindowsSymlinkPrivilegeError: class WindowsSymlinkPrivilegeError extends Error {
-        target;
-        code;
-        constructor(target, code) {
-            super(`symlink skipped: creating a file symlink to ${target} requires a Windows privilege`);
-            this.name = "WindowsSymlinkPrivilegeError";
-            this.target = target;
-            this.code = code;
-        }
-    },
-}));
+vi.mock("../s3.js", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        toPosixKey: (key) => key.split("\\").join("/"),
+        uploadFile: vi.fn().mockResolvedValue({ etag: '"upload-etag"' }),
+        uploadSymlink: vi.fn().mockResolvedValue({ etag: '"upload-symlink-etag"' }),
+        downloadFile: vi.fn().mockResolvedValue(undefined),
+        listRemoteFiles: vi.fn().mockResolvedValue([]),
+        deleteRemoteFile: vi.fn().mockResolvedValue(undefined),
+        headRemoteFile: vi.fn().mockResolvedValue(null),
+        readVerifiedRemoteSymlinkTarget: vi.fn().mockResolvedValue(null),
+        primeObjectTransport: vi.fn().mockResolvedValue(undefined),
+        primeUploads: vi.fn().mockResolvedValue(undefined),
+        // Real exports share.ts now imports for the HQ-DESKTOP-54 privilege skip.
+        WINDOWS_SYMLINK_PRIVILEGE_REMEDY: "Enable Windows Developer Mode (Settings > Privacy & security > For developers) or run HQ sync once from an elevated terminal, then sync again.",
+        WindowsSymlinkPrivilegeError: class WindowsSymlinkPrivilegeError extends Error {
+            target;
+            code;
+            constructor(target, code) {
+                super(`symlink skipped: creating a file symlink to ${target} requires a Windows privilege`);
+                this.name = "WindowsSymlinkPrivilegeError";
+                this.target = target;
+                this.code = code;
+            }
+        },
+        // HQ-DESKTOP-54 (second path): the real win32 rename guard, typed error, and
+        // remedy that share.ts now imports. Real so `instanceof` matches the error the
+        // real helper throws, and the POSIX pass-through keeps existing push tests
+        // byte-identical.
+        renameOrRaiseWindowsBlocked: actual.renameOrRaiseWindowsBlocked,
+        WindowsRenameBlockedError: actual.WindowsRenameBlockedError,
+        WINDOWS_RENAME_BLOCKED_REMEDY: actual.WINDOWS_RENAME_BLOCKED_REMEDY,
+    };
+});
 // 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
@@ -56,6 +66,7 @@ import { share, ServerOwnedPushPathsError, UnreachablePushPathsError, Unregister
 import { deleteRemoteFile, downloadFile, headRemoteFile, primeObjectTransport, primeUploads, uploadFile, uploadSymlink, WindowsSymlinkPrivilegeError, } from "../s3.js";
 import { VaultAuthError, } from "../vault-client.js";
 import { hashFile, readJournal, writeJournal } from "../journal.js";
+import { ReconcileCursorStore } from "../sync/reconcile-cursor.js";
 /**
  * Read a journal the way production does.
  *
@@ -144,6 +155,8 @@ describe("company skill identity preflight", () => {
         stateDir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-share-skill-state-"));
         process.env.HQ_STATE_DIR = stateDir;
         vi.mocked(uploadFile).mockClear();
+        vi.mocked(headRemoteFile).mockReset();
+        vi.mocked(headRemoteFile).mockResolvedValue(null);
     });
     afterEach(() => {
         fs.rmSync(hqRoot, { recursive: true, force: true });
@@ -157,13 +170,16 @@ describe("company skill identity preflight", () => {
         return file;
     }
     function registered(input, uid = "skl_PREFLIGHT1") {
+        const stamped = parseRegisteredCompanySkillUid(input.content)
+            ? input.content
+            : input.content.replace("---\n", `---\nskill_uid: ${uid}\n`);
         return {
             ok: true,
             skillUid: uid,
             path: input.path,
             vaultPath: input.path,
-            content: input.content.replace("---\n", `---\nskill_uid: ${uid}\n`),
-            action: "created",
+            content: stamped,
+            action: parseRegisteredCompanySkillUid(input.content) ? "reused" : "created",
             accessPolicy: "open",
             skill: { name: "Call Prep", description: "Prepare calls", tags: [] },
         };
@@ -177,7 +193,7 @@ describe("company skill identity preflight", () => {
             entityContext: makeEntityContext(),
             registerCompanySkill: registrar,
         });
-        expect(registrar).toHaveBeenCalledWith({
+        expect(registrar).toHaveBeenNthCalledWith(1, {
             companySlug: "acme",
             path: "skills/call-prep/SKILL.md",
             content: expect.stringContaining("name: Call Prep"),
@@ -185,6 +201,12 @@ describe("company skill identity preflight", () => {
         expect(parseRegisteredCompanySkillUid(fs.readFileSync(file, "utf8"))).toBe("skl_PREFLIGHT1");
         expect(result.filesUploaded).toBe(1);
         expect(uploadFile).toHaveBeenCalledWith(expect.anything(), file, "skills/call-prep/SKILL.md", undefined, expect.anything());
+        expect(registrar).toHaveBeenNthCalledWith(2, {
+            companySlug: "acme",
+            path: "skills/call-prep/SKILL.md",
+            content: expect.stringContaining("skill_uid: skl_PREFLIGHT1"),
+            landed: true,
+        });
     });
     it("fails closed without an authenticated registration seam", async () => {
         const file = createSkill("manual", "---\nname: Manual\ndescription: Missing id\n---\n");
@@ -196,17 +218,276 @@ describe("company skill identity preflight", () => {
         expect(uploadFile).not.toHaveBeenCalled();
         expect(parseRegisteredCompanySkillUid(fs.readFileSync(file, "utf8"))).toBeUndefined();
     });
-    it("does not re-register an already stamped canonical skill", async () => {
+    it("reconciles an already stamped canonical skill after upload", async () => {
         const file = createSkill("existing", "---\nname: Existing\ndescription: Ready\nskill_uid: skl_EXISTING1\n---\n");
-        const registrar = vi.fn();
+        const registrar = vi.fn(async (input) => registered(input, "skl_EXISTING1"));
+        const result = await share({
+            paths: [file],
+            hqRoot,
+            entityContext: makeEntityContext(),
+            registerCompanySkill: registrar,
+        });
+        expect(registrar).toHaveBeenCalledOnce();
+        expect(registrar).toHaveBeenCalledWith({
+            companySlug: "acme",
+            path: "skills/existing/SKILL.md",
+            content: expect.stringContaining("skill_uid: skl_EXISTING1"),
+            landed: true,
+        });
+        expect(result.filesUploaded).toBe(1);
+    });
+    it("does not reconcile bytes edited while the upload is in flight", async () => {
+        const original = "---\nname: Existing\ndescription: Ready\nskill_uid: skl_EXISTING1\ntags: [sales]\n---\n";
+        const file = createSkill("existing", original);
+        const registrar = vi.fn(async (input) => registered(input, "skl_EXISTING1"));
+        vi.mocked(uploadFile).mockImplementationOnce(async () => {
+            fs.writeFileSync(file, original.replace("sales", "reporting"));
+            return { etag: '"upload-etag"' };
+        });
         const result = await share({
             paths: [file],
             hqRoot,
             entityContext: makeEntityContext(),
             registerCompanySkill: registrar,
         });
+        expect(result.filesUploaded).toBe(1);
         expect(registrar).not.toHaveBeenCalled();
+    });
+    it("retries a failed post-upload metadata reconciliation without re-uploading", async () => {
+        const file = createSkill("existing", "---\nname: Existing\ndescription: Ready\nskill_uid: skl_EXISTING1\ntags: [sales]\n---\n");
+        const failedRegistrar = vi.fn(async () => {
+            throw new Error("registry temporarily unavailable");
+        });
+        const first = await share({
+            paths: [file],
+            hqRoot,
+            entityContext: makeEntityContext(),
+            registerCompanySkill: failedRegistrar,
+        });
+        expect(first.filesUploaded).toBe(1);
+        expect(readJournal("acme").files["skills/existing/SKILL.md"])
+            .toMatchObject({ skillMetadataPending: true });
+        vi.mocked(uploadFile).mockClear();
+        vi.mocked(headRemoteFile).mockResolvedValue({
+            lastModified: new Date(),
+            etag: '"upload-etag"',
+            size: fs.statSync(file).size,
+        });
+        const healingRegistrar = vi.fn(async (input) => registered(input, "skl_EXISTING1"));
+        const second = await share({
+            paths: [file],
+            hqRoot,
+            entityContext: makeEntityContext(),
+            registerCompanySkill: healingRegistrar,
+            skipUnchanged: true,
+        });
+        expect(second.filesUploaded).toBe(0);
+        expect(uploadFile).not.toHaveBeenCalled();
+        expect(healingRegistrar).toHaveBeenCalledWith(expect.objectContaining({ landed: true }));
+        expect(readJournal("acme").files["skills/existing/SKILL.md"]
+            ?.skillMetadataPending).toBeUndefined();
+    });
+    it("durably records pending skill metadata before starting reconciliation", async () => {
+        const file = createSkill("existing", "---\nname: Existing\ndescription: Ready\nskill_uid: skl_EXISTING1\ntags: [sales]\n---\n");
+        let pendingAtReconcile;
+        const registrar = vi.fn(async (input) => {
+            pendingAtReconcile = readJournal("acme").files["skills/existing/SKILL.md"];
+            return registered(input, "skl_EXISTING1");
+        });
+        await share({
+            paths: [file],
+            hqRoot,
+            entityContext: makeEntityContext(),
+            registerCompanySkill: registrar,
+        });
+        expect(registrar).toHaveBeenCalledOnce();
+        expect(pendingAtReconcile)
+            .toMatchObject({ skillMetadataPending: true, remoteEtag: "upload-etag" });
+    });
+    it("reconciles skill metadata when restart finds identical remote bytes without a journal", async () => {
+        const content = "---\nname: Existing\ndescription: Ready\nskill_uid: skl_EXISTING1\ntags: [sales]\n---\n";
+        const file = createSkill("existing", content);
+        vi.mocked(headRemoteFile).mockResolvedValueOnce({
+            lastModified: new Date(),
+            etag: '"remote-etag"',
+            size: Buffer.byteLength(content),
+        });
+        vi.mocked(downloadFile).mockImplementationOnce(async (_ctx, _key, destination) => {
+            fs.writeFileSync(destination, content);
+            return undefined;
+        });
+        const registrar = vi.fn(async (input) => registered(input, "skl_EXISTING1"));
+        const result = await share({
+            paths: [file],
+            hqRoot,
+            entityContext: makeEntityContext(),
+            registerCompanySkill: registrar,
+        });
+        expect(result.filesUploaded).toBe(0);
+        expect(uploadFile).not.toHaveBeenCalled();
+        expect(registrar).toHaveBeenCalledWith(expect.objectContaining({
+            path: "skills/existing/SKILL.md",
+            content,
+            landed: true,
+        }));
+        expect(readJournal("acme").files["skills/existing/SKILL.md"])
+            .not.toHaveProperty("skillMetadataPending", true);
+    });
+    it("restarts instead of reconciling skill bytes edited after the equality proof", async () => {
+        const original = "---\nname: Existing\ndescription: Ready\nskill_uid: skl_EXISTING1\ntags: [sales]\n---\n";
+        const changed = original.replace("[sales]", "[reporting]");
+        const file = createSkill("existing", original);
+        vi.mocked(headRemoteFile).mockResolvedValue({
+            lastModified: new Date(),
+            etag: '"remote-etag"',
+            size: Buffer.byteLength(original),
+        });
+        vi.mocked(downloadFile).mockImplementation(async (_ctx, _key, destination) => {
+            fs.writeFileSync(destination, original);
+            return undefined;
+        });
+        const realReadFileSync = fs.readFileSync.bind(fs);
+        let skillReads = 0;
+        const readSpy = vi.spyOn(fs, "readFileSync").mockImplementation(((pathname, options) => {
+            if (pathname === file && options === undefined) {
+                skillReads++;
+                if (skillReads === 2)
+                    fs.writeFileSync(file, changed);
+            }
+            return realReadFileSync(pathname, options);
+        }));
+        const registrar = vi.fn(async (input) => registered(input, "skl_EXISTING1"));
+        let result;
+        try {
+            result = await share({
+                paths: [file],
+                hqRoot,
+                entityContext: makeEntityContext(),
+                registerCompanySkill: registrar,
+                onConflict: "overwrite",
+            });
+        }
+        finally {
+            readSpy.mockRestore();
+        }
         expect(result.filesUploaded).toBe(1);
+        expect(uploadFile).toHaveBeenCalledOnce();
+        expect(registrar).toHaveBeenCalledOnce();
+        expect(registrar).toHaveBeenCalledWith(expect.objectContaining({
+            content: changed,
+            landed: true,
+        }));
+    });
+    it("reconciles current remote metadata when the landed upload was replaced", async () => {
+        const file = createSkill("existing", "---\nname: Existing\ndescription: Ready\nskill_uid: skl_EXISTING1\ntags: [sales]\n---\n");
+        const failedRegistrar = vi.fn(async () => {
+            throw new Error("registry temporarily unavailable");
+        });
+        await share({
+            paths: [file],
+            hqRoot,
+            entityContext: makeEntityContext(),
+            registerCompanySkill: failedRegistrar,
+        });
+        expect(readJournal("acme").files["skills/existing/SKILL.md"])
+            .toMatchObject({ skillMetadataPending: true, remoteEtag: "upload-etag" });
+        vi.mocked(uploadFile).mockClear();
+        vi.mocked(headRemoteFile).mockResolvedValue({
+            lastModified: new Date(),
+            etag: '"peer-overwrite"',
+            size: fs.statSync(file).size,
+        });
+        const remote = fs.readFileSync(file, "utf8").replace("[sales]", "[remote]");
+        vi.mocked(downloadFile).mockImplementation(async (_ctx, _key, destination) => {
+            fs.writeFileSync(destination, remote);
+            return {};
+        });
+        const healingRegistrar = vi.fn(async (input) => registered(input, "skl_EXISTING1"));
+        const result = await share({
+            paths: [file],
+            hqRoot,
+            entityContext: makeEntityContext(),
+            registerCompanySkill: healingRegistrar,
+            skipUnchanged: true,
+            onConflict: "keep",
+        });
+        expect(healingRegistrar).toHaveBeenCalledWith(expect.objectContaining({ content: remote, landed: true }));
+        expect(readJournal("acme").files["skills/existing/SKILL.md"]
+            ?.skillMetadataPending).toBeUndefined();
+        expect(result.conflictPaths).toEqual(["skills/existing/SKILL.md"]);
+        expect(fs.readFileSync(file, "utf8")).toBe(remote);
+    });
+    it("preserves entityContext-only uploads of already registered skills", async () => {
+        const file = createSkill("existing", "---\nname: Existing\nskill_uid: skl_EXISTING1\n---\n");
+        const result = await share({
+            paths: [file],
+            hqRoot,
+            entityContext: makeEntityContext(),
+        });
+        expect(result.filesUploaded).toBe(1);
+        expect(readJournal("acme").files["skills/existing/SKILL.md"])
+            .not.toHaveProperty("skillMetadataPending", true);
+    });
+    it("invalidates a replaced remote baseline even when metadata recovery fails", async () => {
+        const file = createSkill("existing", "---\nname: Existing\nskill_uid: skl_EXISTING1\n---\n");
+        await share({
+            paths: [file],
+            hqRoot,
+            entityContext: makeEntityContext(),
+            registerCompanySkill: vi.fn(async () => {
+                throw new Error("registry unavailable");
+            }),
+        });
+        vi.mocked(headRemoteFile).mockResolvedValue({
+            lastModified: new Date(),
+            etag: '"peer-overwrite"',
+            size: fs.statSync(file).size,
+        });
+        vi.mocked(downloadFile).mockRejectedValueOnce(new Error("download failed"));
+        await expect(share({
+            paths: [file],
+            hqRoot,
+            entityContext: makeEntityContext(),
+            registerCompanySkill: vi.fn(async (input) => registered(input, "skl_EXISTING1")),
+            skipUnchanged: true,
+        })).rejects.toThrow("download failed");
+        expect(readJournal("acme").files["skills/existing/SKILL.md"])
+            .toBeUndefined();
+    });
+    it("uploads a local change before reconciling metadata when it lands during remote verification", async () => {
+        const original = "---\nname: Existing\ndescription: Ready\nskill_uid: skl_EXISTING1\ntags: [sales]\n---\n";
+        const file = createSkill("existing", original);
+        const failedRegistrar = vi.fn(async () => {
+            throw new Error("registry temporarily unavailable");
+        });
+        await share({
+            paths: [file],
+            hqRoot,
+            entityContext: makeEntityContext(),
+            registerCompanySkill: failedRegistrar,
+        });
+        vi.mocked(uploadFile).mockClear();
+        vi.mocked(headRemoteFile).mockImplementationOnce(async () => {
+            fs.writeFileSync(file, original.replace("[sales]", "[reporting]"));
+            return {
+                lastModified: new Date(),
+                etag: '"upload-etag"',
+                size: Buffer.byteLength(original),
+            };
+        });
+        const healingRegistrar = vi.fn(async (input) => registered(input, "skl_EXISTING1"));
+        await share({
+            paths: [file],
+            hqRoot,
+            entityContext: makeEntityContext(),
+            registerCompanySkill: healingRegistrar,
+            skipUnchanged: true,
+        });
+        expect(uploadFile).toHaveBeenCalledTimes(1);
+        expect(healingRegistrar).toHaveBeenCalledTimes(1);
+        expect(vi.mocked(uploadFile).mock.invocationCallOrder[0]).toBeLessThan(healingRegistrar.mock.invocationCallOrder[0]);
+        expect(readJournal("acme").files["skills/existing/SKILL.md"]
+            ?.skillMetadataPending).toBeUndefined();
     });
     it("recognizes quoted identities in CRLF frontmatter", () => {
         expect(parseRegisteredCompanySkillUid("---\r\nname: Existing\r\nskill_uid: \"skl_WINDOWS1\"\r\n---\r\n")).toBe("skl_WINDOWS1");
@@ -1710,11 +1991,108 @@ describe("share", () => {
             path: "v7b-priv.txt",
             target: "../target.md",
         }));
-        expect(events.some((e) => e.type === "error")).toBe(false);
+        expect(events.filter((e) => e.type === "error")).toEqual([]);
         // The conflict is still surfaced; the failed adoption restores local.
         expect(result.conflictPaths).toEqual(["v7b-priv.txt"]);
         expect(fs.readFileSync(testFile, "utf-8")).toBe("local-collision-content");
     });
+    it("HQ-DESKTOP-54 (second path): a blocked push conflict-keep move-aside rename is a skip, not an error, and does not touch the local body", async () => {
+        // Push keep moves the local body aside before adopting the remote. On a
+        // Windows host where a program is holding that file open, the move-aside
+        // rename EPERMs; s3 raises the typed WindowsRenameBlockedError
+        // immediately (no retry). The push leg must downgrade it to the
+        // deliberate skip (never type:"error") so the company stays complete and the
+        // runner exits 0 — mirroring the symlink-privilege skip above.
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        fs.mkdirSync(companyRoot, { recursive: true });
+        const testFile = path.join(companyRoot, "v7b-rename.txt");
+        fs.writeFileSync(testFile, "local-collision-content");
+        vi.mocked(headRemoteFile).mockResolvedValueOnce({
+            lastModified: new Date(),
+            etag: '"remote-version-etag"',
+            size: 40,
+        });
+        // The reconciled probe fetches the (divergent) remote so a conflict is
+        // detected; the move-aside rename below is what fails.
+        vi.mocked(downloadFile).mockImplementation(async (_ctx, _key, dest) => {
+            fs.writeFileSync(dest, "peer remote content");
+            return undefined;
+        });
+        const realRenameSync = fs.renameSync;
+        const renameSpy = vi.spyOn(fs, "renameSync").mockImplementation((from, to) => {
+            if (String(from) === testFile && String(to).includes(".conflict-")) {
+                const err = new Error("EPERM: operation not permitted, rename");
+                err.code = "EPERM";
+                throw err;
+            }
+            return realRenameSync(from, to);
+        });
+        const realPlatform = process.platform;
+        Object.defineProperty(process, "platform", { value: "win32", configurable: true });
+        const events = [];
+        let result;
+        try {
+            result = await share({
+                paths: [testFile],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                onConflict: "keep",
+                onEvent: (e) => events.push(e),
+            });
+        }
+        finally {
+            Object.defineProperty(process, "platform", { value: realPlatform, configurable: true });
+            renameSpy.mockRestore();
+        }
+        expect(events).toContainEqual(expect.objectContaining({ type: "skip-rename-blocked", path: "v7b-rename.txt" }));
+        expect(events.some((e) => e.type === "error")).toBe(false);
+        // Nothing was moved or overwritten: the local body is intact and no upload
+        // happened, so the conflict simply re-fires next pass.
+        expect(fs.readFileSync(testFile, "utf-8")).toBe("local-collision-content");
+        expect(result.filesUploaded).toBe(0);
+    });
+    it("HQ-DESKTOP-54 (second path): the push default console logger renders the rename-blocked skip and its remedy (a plain `hq sync` is not silent)", async () => {
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        fs.mkdirSync(companyRoot, { recursive: true });
+        const testFile = path.join(companyRoot, "v7b-render.txt");
+        fs.writeFileSync(testFile, "local-collision-content");
+        vi.mocked(headRemoteFile).mockResolvedValueOnce({
+            lastModified: new Date(),
+            etag: '"remote-version-etag"',
+            size: 40,
+        });
+        vi.mocked(downloadFile).mockImplementation(async (_ctx, _key, dest) => {
+            fs.writeFileSync(dest, "peer remote content");
+            return undefined;
+        });
+        const realRenameSync = fs.renameSync;
+        const renameSpy = vi.spyOn(fs, "renameSync").mockImplementation((from, to) => {
+            if (String(from) === testFile && String(to).includes(".conflict-")) {
+                const err = new Error("EPERM: operation not permitted, rename");
+                err.code = "EPERM";
+                throw err;
+            }
+            return realRenameSync(from, to);
+        });
+        const realPlatform = process.platform;
+        Object.defineProperty(process, "platform", { value: "win32", configurable: true });
+        const warn = vi.spyOn(console, "warn").mockImplementation(() => { });
+        const log = vi.spyOn(console, "log").mockImplementation(() => { });
+        let rendered = [];
+        try {
+            // No onEvent → the push defaultConsoleLogger renders the skip.
+            await share({ paths: [testFile], company: "acme", vaultConfig: mockConfig, hqRoot: tmpDir, onConflict: "keep" });
+            rendered = warn.mock.calls.map((c) => String(c[0]));
+        }
+        finally {
+            Object.defineProperty(process, "platform", { value: realPlatform, configurable: true });
+            warn.mockRestore();
+            log.mockRestore();
+            renameSpy.mockRestore();
+        }
+        expect(rendered.some((line) => /v7b-render\.txt skipped/.test(line) && /holding the file open/i.test(line))).toBe(true);
+    });
     it("fresh-install SSE-KMS etag: byte-identical remote is reconciled without a conflict", async () => {
         const companyRoot = path.join(tmpDir, "companies", "acme");
         fs.mkdirSync(companyRoot, { recursive: true });
@@ -7697,12 +8075,23 @@ describe("nested companies directories in a company vault", () => {
         const midPath = path.join(companyRoot, "audit", "companies", "notes.md");
         fs.mkdirSync(path.dirname(midPath), { recursive: true });
         fs.writeFileSync(midPath, "ordinary segment");
+        const skillRegistrar = async (input) => ({
+            ok: true,
+            skillUid: "skl_SIGNALS1",
+            path: input.path,
+            vaultPath: input.path,
+            content: input.content,
+            action: "reused",
+            accessPolicy: "preserved",
+            skill: { name: "Signals", description: "", tags: [] },
+        });
         const events = [];
         const result = await share({
             paths: [companyRoot],
             company: "acme",
             vaultConfig: mockConfig,
             hqRoot: tmpDir,
+            registerCompanySkill: skillRegistrar,
             onEvent: (e) => events.push(e),
         });
         expect(result.aborted).toBe(false);
@@ -7716,7 +8105,7 @@ describe("nested companies directories in a company vault", () => {
             "audit/companies/notes.md",
         ]));
         expect(events.filter((e) => e.type === "skip-invalid-scoped-key")).toEqual([]);
-        expect(events.some((e) => e.type === "error")).toBe(false);
+        expect(events.filter((e) => e.type === "error")).toEqual([]);
     });
     it("never plans an upload for macOS Finder Icon\\r files — silent skip, valid files still ship", async () => {
         // The incident: Finder writes an `Icon\r` file into every directory it
@@ -7993,4 +8382,45 @@ describe("defaultConsoleLogger — delete refusal wording per reason", () => {
         expect(lines.join("\n")).toContain("ignore-filtered=2, excluded-top-level=1");
     });
 });
+describe("share reconcile apply checkpoint", () => {
+    let hqRoot;
+    let stateDir;
+    beforeEach(() => {
+        hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-share-reconcile-"));
+        stateDir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-share-reconcile-state-"));
+        process.env.HQ_STATE_DIR = stateDir;
+        vi.mocked(uploadFile).mockReset();
+        vi.mocked(uploadFile).mockRejectedValue(new Error("temporary upload failure"));
+        vi.mocked(headRemoteFile).mockResolvedValue(null);
+        vi.mocked(primeUploads).mockResolvedValue(undefined);
+        vi.mocked(primeObjectTransport).mockResolvedValue(undefined);
+    });
+    afterEach(() => {
+        fs.rmSync(hqRoot, { recursive: true, force: true });
+        fs.rmSync(stateDir, { recursive: true, force: true });
+        delete process.env.HQ_STATE_DIR;
+    });
+    it("withholds an apply checkpoint after a per-path upload failure", async () => {
+        const localPath = path.join(hqRoot, "companies", "acme", "notes", "retry.md");
+        fs.mkdirSync(path.dirname(localPath), { recursive: true });
+        fs.writeFileSync(localPath, "retry me");
+        const store = ReconcileCursorStore.open({
+            rootDir: stateDir,
+            journalSlug: "acme",
+            layoutEpoch: 1,
+            areaId: "root:notes",
+        });
+        const result = await share({
+            paths: [localPath],
+            hqRoot,
+            entityContext: makeEntityContext(),
+            reconcileApply: {
+                store,
+                cursor: { routerVersion: 1, epoch: "epoch-1", areaId: "root:notes", phase: "apply", journalAfterKey: "notes/retry.md" },
+            },
+        });
+        expect(result.filesUploaded).toBe(0);
+        expect(store.read().cursor).toBeUndefined();
+    });
+});
 //# sourceMappingURL=share.test.js.map