@indigoai-us/hq-cloud 6.13.5 → 6.14.1

package/src/bin/sync-runner.ts

@@ -723,6 +723,8 @@ interface ParsedArgs {
    * mode (single-company runs never visit the personal target).
    */
   skipPersonal: boolean;
+  /** Repeatable company/personal-relative path scope for push-only passes. */
+  scopePaths: string[];
   /**
    * Bounded wait (seconds) for the per-root operation lock when another op is
    * already running. `0` → refuse immediately (pre-wait behavior); omitted →
@@ -742,6 +744,7 @@ function parseArgs(argv: string[]): ParsedArgs | { error: string } {
   let watch = false;
   let pollRemoteMs: number | undefined;
   let skipPersonal = false;
+  const scopePaths: string[] = [];
   let eventPush = false;
   let lockTimeoutSec: number | undefined;
 
@@ -817,6 +820,12 @@ function parseArgs(argv: string[]): ParsedArgs | { error: string } {
         // @getindigo.ai identities for the first release.
         eventPush = true;
         break;
+      case "--scope-path": {
+        const val = argv[++i];
+        if (!val) return { error: "--scope-path requires a value" };
+        scopePaths.push(val);
+        break;
+      }
       case "--lock-timeout": {
         const val = argv[++i];
         if (!val) return { error: "--lock-timeout requires a value (seconds)" };
@@ -867,6 +876,7 @@ function parseArgs(argv: string[]): ParsedArgs | { error: string } {
     watch,
     pollRemoteMs,
     skipPersonal,
+    scopePaths,
     eventPush,
     lockTimeoutSec,
   };
@@ -1219,6 +1229,7 @@ export async function runRunner(
     shareFn,
     resolveDeletePolicy,
     emit,
+    scopePaths: parsed.scopePaths,
   });
   const { errors, allConflicts } = fanout;
   const rollup = rollupAllComplete(plan, fanout.stateByCompany);

package/src/watcher.test.ts

@@ -350,6 +350,48 @@ describe("US-002: createWatchPathFilter — personal-vault exclusions", () => {
     // mode the ignore stack alone governs and lets it through.
     expect(nonPersonal(path.join(ROOT, "companies/indigo/board.json"))).toBe(true);
   });
+
+  // ── Never-synced heavy buckets pruned in BOTH modes ─────────────────────
+  // In --companies mode personalMode=false, so the excluded-top-level layer
+  // never ran and the watcher descended into the local git worktrees
+  // (workspace/worktrees/, ~200k transient files from agent coding runs) and
+  // the on-box repos checkout (repos/). Neither ever vault-syncs in any mode,
+  // so watching them only burns inotify watches (near the OS limit) + CPU on
+  // build churn it discards, and can trip the overflow→full-reconcile fallback.
+  it("non-personal mode EXCLUDES never-synced heavy buckets (workspace/worktrees, repos)", () => {
+    expect(
+      nonPersonal(path.join(ROOT, "workspace/worktrees/hq-console/src/a.ts")),
+    ).toBe(false);
+    // The bucket dir itself is pruned so chokidar never descends into it.
+    expect(nonPersonal(path.join(ROOT, "workspace/worktrees"), true)).toBe(false);
+    expect(
+      nonPersonal(path.join(ROOT, "repos/private/hq-cloud/src/x.ts")),
+    ).toBe(false);
+    expect(nonPersonal(path.join(ROOT, "repos"), true)).toBe(false);
+  });
+
+  it("non-personal mode STILL watches synced content (companies/, workspace/agency, continuity)", () => {
+    expect(
+      nonPersonal(path.join(ROOT, "companies/indigo/board.json")),
+    ).toBe(true);
+    expect(
+      nonPersonal(path.join(ROOT, "workspace/agency/indigo/nick/status.json")),
+    ).toBe(true);
+    expect(
+      nonPersonal(path.join(ROOT, "workspace/threads/handoff.json")),
+    ).toBe(true);
+    // chokidar must still descend into workspace/ to reach agency + continuity.
+    expect(nonPersonal(path.join(ROOT, "workspace"), true)).toBe(true);
+    // A worktrees SIBLING under workspace/ is unaffected (only worktrees pruned).
+    expect(
+      nonPersonal(path.join(ROOT, "workspace/agency"), true),
+    ).toBe(true);
+  });
+
+  it("personal mode still excludes worktrees + repos (regression, unchanged)", () => {
+    expect(personal(path.join(ROOT, "workspace/worktrees/x/a.ts"))).toBe(false);
+    expect(personal(path.join(ROOT, "repos/private/x/a.ts"))).toBe(false);
+  });
 });
 
 describe("US-002: TreeWatcher — debounce coalesce (FakeClock seam)", () => {

package/src/watcher.ts

@@ -407,6 +407,24 @@ export function createWatchPathFilter(
     // createIgnoreFilter returns true = "sync this"; false = "ignored".
     if (!ignoreFilter(absolutePath, isDir)) return false;
 
+    // Never-synced heavy buckets — pruned in BOTH modes. The local git worktrees
+    // (`workspace/worktrees/`, where `/worktree` and agent coding runs check out
+    // repos — often 100k+ transient source/build files) and the on-box `repos/`
+    // checkout are never vault-synced in any mode. In personalMode the
+    // excluded-top-level layer below already drops them; in `--companies` mode
+    // that layer is skipped, so without this the watcher descends into every
+    // worktree source tree — tens of thousands of wasted inotify watches (the
+    // outpost sat at ~78% of the OS limit) plus CPU spent processing build churn
+    // it immediately discards, and enough backlog to trip the
+    // overflow → full-reconcile fallback. Returning false for the dir probe too
+    // prunes the whole subtree at descent instead of per-file. `companies/` and
+    // the synced `workspace/agency/` + continuity-pointer paths are untouched.
+    const topSegments = rel.split("/");
+    if (topSegments[0] === "repos") return false;
+    if (topSegments[0] === "workspace" && topSegments[1] === "worktrees") {
+      return false;
+    }
+
     if (personalMode) {
       // Continuity-pointer carve-out: the session pointer lives under the
       // otherwise-excluded `workspace/`, so it must re-include BEFORE the