@indigoai-us/hq-cloud 6.14.22 → 6.14.23

package/src/cli/sync.ts

@@ -307,6 +307,32 @@ export type SyncProgressEvent =
       count: number;
       samplePaths: string[];
     }
+  | {
+      /**
+       * Emitted at most ONCE per PULL leg when the leg ran under a
+       * membership-scoped `syncMode` (`"shared"` or `"custom"` — never `"all"`)
+       * AND one or more remote keys were skipped as out-of-scope
+       * (`filesOutOfScope > 0`). This turns the silent shared-vs-all gap into a
+       * VISIBLE, actionable surface. The reporter of feedback_d2082110 lost
+       * files across devices precisely because four memberships defaulted to
+       * `shared` rather than `all`, so not all vault content materialized on the
+       * second device — and nothing told them; they had to notice the gap and
+       * flip each membership to `all` by hand. This event names the gap and the
+       * lever (raise the membership's access level to `all`) so FULL
+       * materialization is a deliberate, visible choice rather than a silent
+       * omission.
+       *
+       * `count` is the number of remote keys skipped as out-of-scope on this
+       * leg; `samplePaths` carries up to 10 company-relative keys for display;
+       * `syncMode` is the active scoped mode. Distinct from the push-side
+       * `scope-excluded` (which reports what a grantee could not PUSH). Not
+       * emitted in `all` mode or when `count === 0` — no gap, no noise.
+       */
+      type: "scope-materialization-gap";
+      count: number;
+      samplePaths: string[];
+      syncMode: SyncMode;
+    }
   | {
       /**
        * Emitted at most ONCE per `share()` push leg when the base ignore
@@ -856,6 +882,8 @@ async function syncWithOperationLockHeld(
   await verifyPlannedJournalTombstones(run, plan);
   executeJournalTombstoneDeletes(run, plan, counters);
 
+  emitScopeMaterializationGap(run, plan, counters);
+
   return finalizePullRun(run, plan, scopeRun, counters);
 }
 
@@ -1170,7 +1198,8 @@ async function executeConflictExecutor(
       item.action === "skip-personal-mode" ||
       item.action === "skip-unchanged" ||
       item.action === "skip-local-only" ||
-      item.action === "skip-stale-overlay-marker"
+      item.action === "skip-stale-overlay-marker" ||
+      item.action === "skip-overlay-marker-with-children"
     ) {
       counters.filesSkipped++;
       continue;
@@ -1844,6 +1873,37 @@ function finalizePullRun(
   };
 }
 
+/**
+ * Surface the shared-vs-all materialization gap (feedback_d2082110). When a
+ * pull leg ran under a membership-scoped `syncMode` and skipped one or more
+ * remote keys as out-of-scope, emit a single summary event so the operator
+ * SEES that not all vault content materialized on this device and knows the
+ * lever — raise the membership's access level to `all`. Silent in `all` mode
+ * (nothing is scoped away) and when nothing fell out of scope: no gap, no
+ * noise. Deliberately AFTER the transfer executors, so `filesOutOfScope` is
+ * final; sample keys are read off the plan's `skip-out-of-scope` items (pure,
+ * no I/O). This is the visible complement to the previously-silent
+ * `SyncResult.filesOutOfScope` count.
+ */
+function emitScopeMaterializationGap(
+  run: PullRunContext,
+  plan: PullPlan,
+  counters: PullCounters,
+): void {
+  if (run.syncMode === "all") return;
+  if (counters.filesOutOfScope <= 0) return;
+  const samplePaths = plan.items
+    .filter((item) => item.action === "skip-out-of-scope")
+    .slice(0, 10)
+    .map((item) => item.remoteFile.key);
+  run.emit({
+    type: "scope-materialization-gap",
+    count: counters.filesOutOfScope,
+    samplePaths,
+    syncMode: run.syncMode,
+  });
+}
+
 /**
  * Decide whether a remote object present in the LIST is a GENUINE RE-CREATE
  * written AFTER a FILE_TOMBSTONE — in which case the tombstone is stale and the
@@ -2034,6 +2094,15 @@ type PullPlanItem =
   // no-action-needed case is never surfaced with the alarming "rm -rf the
   // local directory" reconciliation advice.
   | { action: "skip-stale-overlay-marker"; remoteFile: RemoteFile; localPath: string }
+  // A directory-overlay marker (a single vault object at a key that ALSO has
+  // child objects under it in the same LIST — a symlink record for a directory
+  // mirrored from another tree) colliding with a local REAL directory whose
+  // contents are already materialized. The marker can never be renamed over the
+  // directory; its children carry the real content and materialize via their own
+  // plan items. A benign, no-action skip — distinct from skip-local-only so the
+  // case is never surfaced with the alarming (and, for a materialized directory,
+  // data-destroying) "rm -rf the local directory to pull" advice. feedback_d2082110.
+  | { action: "skip-overlay-marker-with-children"; remoteFile: RemoteFile; localPath: string }
   // Remote keys refused by ephemeral-mirror policy. The push walker has
   // refused to upload these since 5.33.0; the pull walker now refuses to
   // download them so legacy litter in cloud staging drains naturally.
@@ -2176,6 +2245,28 @@ function computePullPlan(
     localPath: string;
   }> = [];
 
+  // Remote keys that ALSO appear as an ancestor of another remote key — i.e.
+  // keys that carry child objects under `${key}/…` in this same LIST. The
+  // vault stores a directory OVERLAY (a symlink into another tree, e.g. a
+  // company skill mirrored from a shared repo) as a symlink RECORD at the
+  // directory's own key AND stores the directory's contents as separate child
+  // objects beneath it. A REAL directory, by contrast, only ever syncs as
+  // those child objects — never as a single object AT its own key. So a single
+  // remote object sitting at a key that also has children is unambiguously a
+  // directory-overlay marker, not a regular file. Precomputed once (pure path
+  // derivation, no I/O — the planner is synchronous) so the dir-vs-object
+  // collision branch can tell an inert overlay marker apart from a genuine
+  // file-vs-directory structural collision. feedback_d2082110.
+  const remoteKeysWithChildren = new Set<string>();
+  for (const rf of remoteFiles) {
+    const key = toPosixKey(rf.key);
+    let slash = key.indexOf("/");
+    while (slash !== -1) {
+      remoteKeysWithChildren.add(key.slice(0, slash));
+      slash = key.indexOf("/", slash + 1);
+    }
+  }
+
   for (const remoteFile of remoteFiles) {
     const invalidKey = classifyVaultKey(
       remoteFile.key,
@@ -2437,6 +2528,30 @@ function computePullPlan(
           });
           continue;
         }
+        // Directory-overlay marker vs. a locally-materialized directory:
+        // the remote object at this key carries CHILD objects under it in the
+        // same LIST (`remoteKeysWithChildren`), so it is a symlink/overlay
+        // record for a directory — e.g. the DPP vault's `skills/cody-copywriter`
+        // overlay whose 13 child objects are already materialized locally. The
+        // marker can never be renamed over the real directory, and its children
+        // carry the actual content and materialize via their own plan items, so
+        // the marker is a benign, no-action skip. The generic "rm -rf the local
+        // directory to pull" advice below would tell the operator to DELETE the
+        // materialized (and possibly locally-authored) contents to install an
+        // inert link, and it recurred on EVERY sync cycle. feedback_d2082110.
+        if (remoteKeysWithChildren.has(toPosixKey(remoteFile.key))) {
+          console.error(
+            `  Note: ${remoteFile.key} is a directory-overlay marker whose ` +
+              `contents already exist locally as a directory; keeping the ` +
+              `local directory and ignoring the marker (no action needed).`,
+          );
+          items.push({
+            action: "skip-overlay-marker-with-children",
+            remoteFile,
+            localPath,
+          });
+          continue;
+        }
         console.error(
           `  Warning: ${remoteFile.key} exists locally as a directory; ` +
             `cloud has a single object at this key. Skipping; manual ` +
@@ -2896,6 +3011,16 @@ function defaultConsoleLogger(event: SyncProgressEvent): void {
     if (event.count > event.samplePaths.length) {
       console.log(`    ... and ${event.count - event.samplePaths.length} more`);
     }
+  } else if (event.type === "scope-materialization-gap") {
+    console.warn(
+      `  ! ${event.count} item${event.count === 1 ? "" : "s"} in this vault did NOT sync to this device — your access level is "${event.syncMode}", so only shared paths materialize. To pull everything you have access to, set this membership's access level to "all":`,
+    );
+    for (const p of event.samplePaths) {
+      console.warn(`    · ${p}`);
+    }
+    if (event.count > event.samplePaths.length) {
+      console.warn(`    ... and ${event.count - event.samplePaths.length} more`);
+    }
   } else if (event.type === "ignore-excluded") {
     console.warn(
       `  ! ${event.count} path${event.count === 1 ? "" : "s"} were EXCLUDED from sync by an ignore rule and did NOT reach the vault (review in case this is unintended):`,

package/src/lib/conflict-index.ts

@@ -136,6 +136,13 @@ export interface PruneConflictIndexResult {
   removedMirrors: number;
   /** Rows kept (genuine divergence, or unprovable — fail-safe retained). */
   kept: number;
+  /**
+   * Up to 10 ORIGINAL (non-mirror) paths of the kept rows, for a
+   * post-sync reconcile surface (`conflicts-remaining`). Empty when
+   * `kept === 0`. Lets a caller name the preserved conflict variants a human
+   * still has to resolve without re-reading the index. feedback_d2082110.
+   */
+  keptSamplePaths: string[];
 }
 
 /**
@@ -198,6 +205,7 @@ export function pruneConflictIndex(hqRoot: string): PruneConflictIndexResult {
     prunedIdentical: 0,
     removedMirrors: 0,
     kept: 0,
+    keptSamplePaths: [],
   };
 
   const index = readConflictIndex(hqRoot);
@@ -254,6 +262,9 @@ export function pruneConflictIndex(hqRoot: string): PruneConflictIndexResult {
     }
   }
 
+  // Name the preserved divergences for the post-sync reconcile surface.
+  result.keptSamplePaths = kept.slice(0, 10).map((e) => e.originalPath);
+
   // No row dropped → leave the file (and its mtime) untouched.
   if (kept.length === index.conflicts.length) return result;
 

package/src/lib/conflict.test.ts

@@ -194,6 +194,7 @@ describe("pruneConflictIndex", () => {
       prunedIdentical: 0,
       removedMirrors: 0,
       kept: 0,
+      keptSamplePaths: [],
     });
     expect(fs.existsSync(getConflictIndexPath(tmpHq))).toBe(false);
   });
@@ -292,6 +293,7 @@ describe("pruneConflictIndex", () => {
       prunedIdentical: 1,
       removedMirrors: 1,
       kept: 1,
+      keptSamplePaths: ["dir/real.md"],
     });
     expect(readConflictIndex(tmpHq).conflicts.map((c) => c.id)).toEqual(["real"]);
   });
@@ -312,4 +314,35 @@ describe("pruneConflictIndex", () => {
     pruneConflictIndex(tmpHq);
     expect(fs.statSync(indexPath).mtimeMs).toBe(before);
   });
+
+  it("names the preserved conflict variants (keptSamplePaths, capped at 10) for the reconcile surface (feedback_d2082110)", () => {
+    // Reporter feedback_d2082110 finished a full sync with "20 older preserved
+    // conflict entries" still on disk and NO signal they were there. The prune
+    // self-heals the ledger but conservatively KEEPS genuine divergences; those
+    // were silent. keptSamplePaths surfaces the original (non-mirror) paths so
+    // the runner can emit a `conflicts-remaining` reconcile line pointing the
+    // operator at `/resolve-conflicts`.
+    const rows: ConflictIndexEntry[] = [];
+    for (let i = 0; i < 12; i++) {
+      const id = `real-${String(i).padStart(2, "0")}`;
+      const row = rowFor(id);
+      put(row.originalPath, `local-${i}`);
+      put(row.conflictPath, `remote-${i}`);
+      rows.push(row);
+    }
+    writeConflictIndex(tmpHq, { version: 1, conflicts: rows });
+
+    const res = pruneConflictIndex(tmpHq);
+    expect(res.kept).toBe(12);
+    // Capped at 10 samples, drawn from the kept (detectedAt-sorted) rows.
+    expect(res.keptSamplePaths).toHaveLength(10);
+    expect(res.keptSamplePaths.every((p) => p.startsWith("dir/real-"))).toBe(true);
+    // Orphaned/identical rows never contribute to the surfaced sample.
+    const orphan = rowFor("orphan");
+    put(orphan.originalPath, "x"); // mirror missing → dropped, not sampled
+    writeConflictIndex(tmpHq, { version: 1, conflicts: [orphan] });
+    const res2 = pruneConflictIndex(tmpHq);
+    expect(res2.kept).toBe(0);
+    expect(res2.keptSamplePaths).toEqual([]);
+  });
 });