@indigoai-us/hq-cloud 6.11.7 → 6.11.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cloud",
-  "version": "6.11.7",
+  "version": "6.11.8",
   "description": "HQ by Indigo cloud sync engine — bidirectional S3 sync for mobile access",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/cli/share.test.ts

@@ -4326,7 +4326,7 @@ describe("currency-gated: journal version 2 fixtures", () => {
       expect(errorEvents[0]!.path).toBe("f-2.bin");
     });
 
-    // ── Codex P1 (5.36.x): interactive conflict prompt serialization ────
+    // ── Interactive conflict prompt serialization ───────────────────────
     //
     // The parallel pool can run multiple processUploadItem workers
     // concurrently; each worker calls resolveConflict() on a conflict, and
@@ -4334,12 +4334,11 @@ describe("currency-gated: journal version 2 fixtures", () => {
     // 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.
+    // Fix: rather than force the WHOLE pool to concurrency=1 (which made an
+    // interactive `hq sync now` crawl even with zero conflicts), the pool
+    // keeps full concurrency and serializes ONLY the prompt via a chained
+    // lock (`resolveConflictSerialized`). At most one prompt awaits input at
+    // a time; this test pins that invariant.
     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 });
@@ -4451,6 +4450,59 @@ describe("currency-gated: journal version 2 fixtures", () => {
       expect(maxConcurrent).toBeGreaterThanOrEqual(4);
     });
 
+    it("interactive mode (onConflict unset) still runs transfers concurrently", async () => {
+      // REGRESSION: the 5.36.x interactive guard forced the WHOLE pool to
+      // concurrency=1 whenever onConflict was unset — so `hq sync now` (which
+      // omits --on-conflict) crawled through transfers one at a time even when
+      // no conflict ever occurred. The prompt is now serialized on its own
+      // chained lock, leaving the transfer pool at full concurrency.
+      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: number[] = [];
+      const endTimes: number[] = [];
+      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 intentionally omitted → interactive mode. No conflicts
+        // occur, so the transfer pool must NOT serialize.
+      });
+
+      const sortedEvents: Array<{ t: number; kind: "start" | "end" }> = [];
+      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--;
+        }
+      }
+      // Pre-fix this was exactly 1 (forced serial). Now it tracks the full
+      // pool; 4 is a conservative lower bound to avoid CI flakiness.
+      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

package/src/cli/share.ts

@@ -1070,24 +1070,41 @@ export async function share(options: ShareOptions): Promise<ShareResult> {
   // PUTs that already issued will complete (S3 doesn't have client-side
   // cancellation in this code path); their results are still recorded on
   // the journal so the next sync's planner doesn't re-fire them.
-  // Interactive-mode guard (Codex P1, 5.36.x): when onConflict is unset
-  // the per-item conflict path falls into resolveConflict()'s readline
-  // prompt on process.stdin. Multiple pool workers prompting at once
-  // would race for the same terminal input and interleave answers
-  // nondeterministically. Force concurrency=1 for interactive sessions —
-  // the operator is at the keyboard anyway, the throughput penalty only
-  // applies when conflicts actually exist, and Option A (whole-pool
-  // serialization) has the smallest blast radius vs. a per-prompt mutex.
-  // Non-interactive (onConflict set) keeps the env-tunable default.
-  const isInteractiveConflictMode = onConflict === undefined;
+  // Interactive-mode prompts: when `onConflict` is unset the per-item conflict
+  // path calls resolveConflict()'s readline prompt on process.stdin, and two
+  // pool workers prompting at once would race for the terminal and interleave
+  // answers. The 5.36.x guard solved this by forcing the WHOLE pool to
+  // concurrency=1 — which made an interactive `hq sync now` crawl even when
+  // zero conflicts existed (every transfer serialized just in case one might
+  // prompt). Instead, keep full env-tunable concurrency and serialize ONLY the
+  // prompt (see `resolveConflictSerialized` below): at most one prompt awaits
+  // input at a time while transfers stay parallel.
   const TRANSFER_CONCURRENCY = (() => {
-    if (isInteractiveConflictMode) return 1;
     const raw = process.env.HQ_SYNC_TRANSFER_CONCURRENCY;
     if (raw === undefined || raw === "") return 16;
     const parsed = Number.parseInt(raw, 10);
     return Number.isFinite(parsed) && parsed > 0 ? parsed : 16;
   })();
 
+  // Chained lock around the (possibly interactive) conflict prompt. Each
+  // resolveConflict() runs only after the previous one settles, so concurrent
+  // pool workers never prompt over each other on stdin — without dropping the
+  // transfer pool's parallelism. A rejected prompt must not wedge the chain,
+  // so the link swallows errors (the original promise still rejects to its
+  // awaiter). In non-interactive mode resolveConflict applies the configured
+  // strategy without reading stdin, so the lock adds no real serialization.
+  let conflictPromptChain: Promise<unknown> = Promise.resolve();
+  const resolveConflictSerialized = (
+    info: Parameters<typeof resolveConflict>[0],
+  ): ReturnType<typeof resolveConflict> => {
+    const run = conflictPromptChain.then(() => resolveConflict(info, onConflict));
+    conflictPromptChain = run.then(
+      () => undefined,
+      () => undefined,
+    );
+    return run;
+  };
+
   // Push-side FILE_TOMBSTONE consult (delete-resync) — symmetric to the pull
   // planner's suppression in sync.ts. An authoritative delete
   // (`hq files delete <prefix>`) writes a FILE_TOMBSTONE and removes the S3
@@ -1333,15 +1350,12 @@ export async function share(options: ShareOptions): Promise<ShareResult> {
       if ((localChanged && remoteChanged) || isFreshCollision) {
         conflictPaths.push(relativePath);
 
-        const resolution = await resolveConflict(
-          {
-            path: relativePath,
-            localHash,
-            remoteModified: remoteMeta.lastModified,
-            direction: "push",
-          },
-          onConflict,
-        );
+        const resolution = await resolveConflictSerialized({
+          path: relativePath,
+          localHash,
+          remoteModified: remoteMeta.lastModified,
+          direction: "push",
+        });
 
         emit({
           type: "conflict",
@@ -1481,10 +1495,11 @@ export async function share(options: ShareOptions): Promise<ShareResult> {
         // the race the fence exists to catch. Surface as a push conflict;
         // never silently overwrite.
         conflictPaths.push(relativePath);
-        const resolution = await resolveConflict(
-          { path: relativePath, localHash, direction: "push" },
-          onConflict,
-        );
+        const resolution = await resolveConflictSerialized({
+          path: relativePath,
+          localHash,
+          direction: "push",
+        });
         emit({
           type: "conflict",
           path: relativePath,