@indigoai-us/hq-cloud 6.15.78 → 6.15.80

package/dist/cli/share.test.js

@@ -56,6 +56,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 +145,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 +160,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 +183,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 +191,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 +208,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,7 +1981,7 @@ 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");
@@ -7697,12 +7968,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 +7998,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 +8275,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