@indigoai-us/hq-cloud 6.13.0 → 6.13.1

package/src/cli/reindex.ts

@@ -223,6 +223,17 @@ export function reindex(opts: ReindexOptions = {}): ReindexResult {
   }
   try {
 
+  // Overlay/skill-wrapper mirroring is best-effort and, on a normal synced HQ,
+  // legitimately no-ops for MANY entries (a real core file already sits where a
+  // symlink would go, or a link already points elsewhere). Emitting one stderr
+  // line PER such entry floods the runner's Sentry breadcrumb ring (100 entries)
+  // and evicts the real per-company sync error, making code-2 syncs impossible to
+  // triage (HQ-SYNC-2 / HQ-SYNC-WEB-6). Collapse those per-file lines into a
+  // single end-of-run summary; keep per-file detail behind HQ_REINDEX_VERBOSE=1.
+  const verbose = process.env.HQ_REINDEX_VERBOSE === "1";
+  let skippedNonSymlink = 0;
+  let skippedPointsElsewhere = 0;
+
   // Best-effort: each wrapper mkdir below is recursive and re-creates this
   // parent as needed, so a failure here is non-fatal — warn and carry on so
   // personal-overlay mirroring and registry regeneration still run.
@@ -341,12 +352,18 @@ export function reindex(opts: ReindexOptions = {}): ReindexResult {
         if (lst && lst.isSymbolicLink()) {
           const current = readlinkOrNull(linkPath);
           if (current === relativeTarget) continue;
-          warn(
-            `reindex: .claude/skills/${wrapperName}/${entry} already points to '${current}' (expected '${relativeTarget}'); leaving alone`,
-          );
+          skippedPointsElsewhere++;
+          if (verbose) {
+            warn(
+              `reindex: .claude/skills/${wrapperName}/${entry} already points to '${current}' (expected '${relativeTarget}'); leaving alone`,
+            );
+          }
           continue;
         } else if (lst) {
-          warn(`reindex: ${linkPath} already exists and is not a symlink; skipping`);
+          skippedNonSymlink++;
+          if (verbose) {
+            warn(`reindex: ${linkPath} already exists and is not a symlink; skipping`);
+          }
           continue;
         }
 
@@ -440,12 +457,18 @@ export function reindex(opts: ReindexOptions = {}): ReindexResult {
       if (lst && lst.isSymbolicLink()) {
         const current = readlinkOrNull(linkPath);
         if (current === relativeTarget) continue;
-        warn(
-          `reindex: core/${type}/${entry} already points to '${current}' (expected '${relativeTarget}'); leaving alone`,
-        );
+        skippedPointsElsewhere++;
+        if (verbose) {
+          warn(
+            `reindex: core/${type}/${entry} already points to '${current}' (expected '${relativeTarget}'); leaving alone`,
+          );
+        }
         continue;
       } else if (lst) {
-        warn(`reindex: core/${type}/${entry} already exists and is not a symlink; skipping`);
+        skippedNonSymlink++;
+        if (verbose) {
+          warn(`reindex: core/${type}/${entry} already exists and is not a symlink; skipping`);
+        }
         continue;
       }
 
@@ -463,6 +486,22 @@ export function reindex(opts: ReindexOptions = {}): ReindexResult {
     spawnSync("bash", [genScript], { stdio: ["ignore", 2, 2] });
   }
 
+  // One-line summary in place of the per-file overlay-skip spam (see the comment
+  // at the top of the try). Only emitted when something was skipped, so a clean
+  // run stays silent and the breadcrumb ring is free for real sync errors.
+  if (skippedNonSymlink > 0 || skippedPointsElsewhere > 0) {
+    const parts: string[] = [];
+    if (skippedNonSymlink > 0) {
+      parts.push(`${skippedNonSymlink} pre-existing non-symlink ${skippedNonSymlink === 1 ? "entry" : "entries"}`);
+    }
+    if (skippedPointsElsewhere > 0) {
+      parts.push(`${skippedPointsElsewhere} ${skippedPointsElsewhere === 1 ? "entry" : "entries"} already pointing elsewhere`);
+    }
+    warn(
+      `reindex: left ${parts.join(" + ")} untouched (overlay mirror is best-effort; set HQ_REINDEX_VERBOSE=1 for per-file detail)`,
+    );
+  }
+
   return { status: 0 };
   } finally {
     opLock?.release();

package/src/journal.test.ts

@@ -25,6 +25,7 @@ import {
   gcTombstones,
   generatePullId,
   TOMBSTONE_TTL_MS,
+  MAX_PULLS_PER_COMPANY,
   PERSONAL_VAULT_JOURNAL_SLUG,
   migratePersonalVaultJournal,
   listJournals,
@@ -463,6 +464,49 @@ describe("journal", () => {
         "2026-05-20T00:00:00.000Z",
       );
     });
+
+    it("bounds pulls per company and preserves newest lastPullRecord", () => {
+      const j: SyncJournal = {
+        version: "2",
+        lastSync: "",
+        files: {},
+        pulls: [],
+      };
+      const completedAt = (n: number) =>
+        `2026-05-20T00:00:${String(n).padStart(2, "0")}.000Z`;
+
+      for (let i = 0; i < MAX_PULLS_PER_COMPANY + 5; i++) {
+        appendPullRecord(
+          j,
+          pull({
+            pullId: `pull-a-${String(i).padStart(2, "0")}`,
+            companyUid: "cmp_a",
+            completedAt: completedAt(i),
+          }),
+        );
+      }
+      for (let i = 0; i < 3; i++) {
+        appendPullRecord(
+          j,
+          pull({
+            pullId: `pull-b-${i}`,
+            companyUid: "cmp_b",
+            completedAt: completedAt(i),
+          }),
+        );
+      }
+
+      const pulls = j.pulls ?? [];
+      const companyA = pulls.filter((p) => p.companyUid === "cmp_a");
+      const companyB = pulls.filter((p) => p.companyUid === "cmp_b");
+      expect(companyA).toHaveLength(MAX_PULLS_PER_COMPANY);
+      expect(companyB).toHaveLength(3);
+      expect(companyA[0].pullId).toBe("pull-a-05");
+      expect(companyA.at(-1)?.pullId).toBe("pull-a-54");
+      expect(companyA.some((p) => p.pullId === "pull-a-00")).toBe(false);
+      expect(lastPullRecord(j, "cmp_a")?.pullId).toBe("pull-a-54");
+      expect(lastPullRecord(j, "cmp_b")?.pullId).toBe("pull-b-2");
+    });
   });
 
   describe("tombstoneEntry + isTombstone", () => {

package/src/journal.ts

@@ -26,6 +26,13 @@ export const TOMBSTONE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 /** Current journal schema version written by all v2-aware writers. */
 export const JOURNAL_VERSION_CURRENT = "2" as const;
 
+/**
+ * Retain bounded pull history per company. Scope-shrink logic only needs the
+ * newest record, but a small tail keeps diagnostics useful without letting
+ * long-running sync loops grow journals forever.
+ */
+export const MAX_PULLS_PER_COMPANY = 50;
+
 const JOURNAL_FILE_PREFIX = "sync-journal.";
 const JOURNAL_FILE_SUFFIX = ".json";
 const JOURNAL_LAST_GOOD_SUFFIX = ".last-good";
@@ -517,13 +524,41 @@ export function lastPullRecord(
   return best;
 }
 
-/** Append a `PullRecord` (mutates `journal.pulls`). */
+function trimPullRecords(journal: SyncJournal): void {
+  const pulls = journal.pulls;
+  if (!pulls || pulls.length === 0) return;
+
+  const byCompany = new Map<string, Array<{ record: PullRecord; index: number }>>();
+  pulls.forEach((record, index) => {
+    const entries = byCompany.get(record.companyUid);
+    if (entries) entries.push({ record, index });
+    else byCompany.set(record.companyUid, [{ record, index }]);
+  });
+
+  const keep = new Set<number>();
+  for (const entries of byCompany.values()) {
+    entries
+      .sort((a, b) => {
+        const byCompletedAt = b.record.completedAt.localeCompare(
+          a.record.completedAt,
+        );
+        return byCompletedAt === 0 ? b.index - a.index : byCompletedAt;
+      })
+      .slice(0, MAX_PULLS_PER_COMPANY)
+      .forEach((entry) => keep.add(entry.index));
+  }
+
+  journal.pulls = pulls.filter((_, index) => keep.has(index));
+}
+
+/** Append a `PullRecord` (mutates `journal.pulls`) and cap retained history. */
 export function appendPullRecord(
   journal: SyncJournal,
   record: PullRecord,
 ): void {
   migrateToV2(journal);
   journal.pulls!.push(record);
+  trimPullRecords(journal);
 }
 
 /**

package/src/skill-telemetry.test.ts

@@ -226,6 +226,30 @@ describe("extractCodexSkillToolEvents (Codex model-driven SKILL.md reads)", () =
     expect(ev.source).toBe("model");
   });
 
+  it("matches normal Codex skill paths without backtracking ambiguity", () => {
+    expect(
+      extractCodexSkillToolEvents(
+        execEnd("cat /home/u/.claude/skills/hq/land/SKILL.md"),
+        ctx,
+      )[0].skill,
+    ).toBe("land");
+    expect(
+      extractCodexSkillToolEvents(
+        execEnd("cat /home/u/.claude/skills/a/b/c/SKILL.md"),
+        ctx,
+      )[0].skill,
+    ).toBe("c");
+  });
+
+  it("returns quickly for pathological non-matching skills paths", () => {
+    const cmd = "/home/u/.claude/skills/" + "a/".repeat(2000) + "z z";
+    const started = Date.now();
+    const events = extractCodexSkillToolEvents(execEnd(cmd), ctx);
+    const elapsedMs = Date.now() - started;
+    expect(events).toEqual([]);
+    expect(elapsedMs).toBeLessThan(200);
+  });
+
   it("absolute and relative SKILL.md paths both resolve", () => {
     expect(
       extractCodexSkillToolEvents(execEnd("cat /abs/path/.agents/skills/quiz/SKILL.md"), ctx)[0].skill,

package/src/skill-telemetry.ts

@@ -342,10 +342,11 @@ export function extractCodexSkillEvents(
  *  may be nested arbitrarily deep (`.agents/skills/…`, `.codex/skills/hq/…`),
  *  and `<name>` is always the directory immediately above SKILL.md — captured
  *  as the last segment so the bridge's `skills/hq/<name>/` layout resolves to
- *  `<name>`, not `hq`. The leading `(?:…/)*` is non-greedy via the segment class
- *  so it stops at the final directory boundary. */
+ *  `<name>`, not `hq`. The segment classes deliberately exclude `/` so segment
+ *  boundaries are unambiguous and non-matching `skills/...` paths cannot
+ *  catastrophically backtrack. */
 const CODEX_SKILL_FILE =
-  /(?:^|\/)skills\/(?:[^\s'"]+\/)*?([^/\s'"]+)\/SKILL\.md\b/;
+  /(?:^|\/)skills\/(?:[^/\s'"]+\/)*?([^/\s'"]+)\/SKILL\.md\b/;
 
 /** Pull the shell command string out of a Codex `exec_command_end` `command`,
  *  which is `["/bin/zsh", "-lc", "<cmd>"]` (array) on the runtimes we see, but
@@ -488,6 +489,8 @@ export function extractCodexSkillToolEvents(
   const exec = codexExecParams(obj, payload, ctx);
   if (!exec) return [];
   const { cmd } = exec;
+  // Real exec commands are tiny; avoid running regexes over pathological rows.
+  if (cmd.length > 100_000) return [];
   const m = CODEX_SKILL_FILE.exec(cmd);
   if (!m) return [];
   // Confirm the exec is a read of the skill file, not a write to it. Codex's own