@indigoai-us/hq-cloud 6.14.0 → 6.14.2

package/src/watcher.ts

@@ -14,12 +14,18 @@ import { watch } from "chokidar";
 import { createIgnoreFilter } from "./ignore.js";
 import { isPersonalVaultExcluded } from "./personal-vault-exclusions.js";
 import {
+  AGENCY_SYNC_REL,
   CONTINUITY_POINTER_REL,
   PERSONAL_VAULT_EXCLUDED_TOP_LEVEL,
 } from "./personal-vault.js";
 import type { PushEvent } from "./sync/push-event.js";
 import type { PushTransport } from "./sync/push-transport.js";
 import type { EventDrivenPushFlagProvider } from "./sync/feature-flags.js";
+import {
+  emitCloudTelemetry,
+  type CloudTelemetryClient,
+  type TelemetryClaims,
+} from "./telemetry-events.js";
 
 const DEBOUNCE_MS = 2000;
 
@@ -407,6 +413,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
@@ -428,6 +452,20 @@ export function createWatchPathFilter(
       if (rel === CONTINUITY_POINTER_REL && !isDir) return true;
       if (isDir && CONTINUITY_POINTER_REL.startsWith(rel + "/")) return true;
 
+      // Agency-workspace carve-out: `workspace/agency/` (the whole subtree) IS
+      // synced via computeAgencySyncPaths (mirrored on the push side), so it must
+      // re-include BEFORE the top-level `workspace/` rejection below — same
+      // reason as the continuity pointer above, but for an entire subtree rather
+      // than one file. Without this, a `--personal --watch` runner never emits
+      // agency changes and they wait for the 60s poll. Paths at/under agency
+      // emit (handleEvent always probes isDir=false); agency itself and its
+      // ancestor dir (`workspace`) return true for the dir probe so chokidar
+      // descends to reach them instead of pruning `workspace/`.
+      if (rel === AGENCY_SYNC_REL || rel.startsWith(AGENCY_SYNC_REL + "/")) {
+        return true;
+      }
+      if (isDir && AGENCY_SYNC_REL.startsWith(rel + "/")) return true;
+
       // Layer 3: excluded top-level buckets (.git/companies/repos/workspace).
       const topLevel = rel.split("/")[0];
       if (excludedTopLevel.has(topLevel)) return false;
@@ -792,6 +830,9 @@ export interface PushEventEmitterOptions {
    * no log (the daemon stays quiet unless wired with a logger).
    */
   logger?: EmitterLogger;
+  /** Optional hq-pro ACTION telemetry sink. Best-effort; never affects publish. */
+  telemetryClient?: CloudTelemetryClient | null;
+  telemetryClaims?: TelemetryClaims | null;
 }
 
 /**
@@ -816,6 +857,8 @@ export class PushEventEmitter {
   private readonly now: () => Date;
   private readonly onError: (err: Error, ctx: { relativePath?: string }) => void;
   private readonly logger: EmitterLogger | undefined;
+  private readonly telemetryClient: CloudTelemetryClient | null | undefined;
+  private readonly telemetryClaims: TelemetryClaims | null | undefined;
   private internalSeq = 0;
   private readonly nextSeq: () => number;
   private publishTail: Promise<void> = Promise.resolve();
@@ -827,6 +870,8 @@ export class PushEventEmitter {
     this.flagProvider = opts.flagProvider;
     this.now = opts.now ?? (() => new Date());
     this.logger = opts.logger;
+    this.telemetryClient = opts.telemetryClient;
+    this.telemetryClaims = opts.telemetryClaims;
     this.onError =
       opts.onError ??
       ((err, ctx) =>
@@ -927,6 +972,7 @@ export class PushEventEmitter {
         this.onError(err instanceof Error ? err : new Error(String(err)), {
           relativePath,
         });
+        this.emitPublishTelemetry("push_event_failed", "unknown", "capture");
         return;
       }
 
@@ -962,12 +1008,35 @@ export class PushEventEmitter {
 
     try {
       await this.transport.publish(event);
+      this.emitPublishTelemetry("push_event_published", event.kind, "publish");
     } catch (err) {
       // Push failure (network / non-2xx / timeout). The cadence poll is the
       // safety net — log + continue, never throw.
       this.onError(err instanceof Error ? err : new Error(String(err)), {
         relativePath,
       });
+      this.emitPublishTelemetry("push_event_failed", event.kind, "publish");
     }
   }
+
+  private emitPublishTelemetry(
+    eventName: "push_event_published" | "push_event_failed",
+    kind: string,
+    stage: string,
+  ): void {
+    void emitCloudTelemetry(
+      this.telemetryClient,
+      {
+        eventName,
+        source: "watcher",
+        properties: {
+          kind,
+          count: 1,
+          result: eventName === "push_event_published" ? "success" : "failure",
+          stage,
+        },
+      },
+      { claims: this.telemetryClaims },
+    );
+  }
 }