@indigoai-us/hq-cloud 6.14.31 → 6.14.32

package/src/qmd-reindex.test.ts

@@ -103,7 +103,7 @@ describe("reindexAfterSync", () => {
       acquireReindexLock: noLock,
       existsSync: () => true,
       readCompanies: () => ["acme"],
-      hasIndexableMarkdown: () => true,
+      hasIndexableMarkdown: (p) => p === path.join("/hq", "companies", "acme", "knowledge"),
     });
     expect(r.qmdAvailable).toBe(true);
     expect(r.collectionsAdded).toEqual(["acme"]);
@@ -126,7 +126,7 @@ describe("reindexAfterSync", () => {
       acquireReindexLock: noLock,
       existsSync: () => true,
       readCompanies: () => ["acme"],
-      hasIndexableMarkdown: () => true,
+      hasIndexableMarkdown: (p) => p === path.join("/hq", "companies", "acme", "knowledge"),
       realpathSync: identityRealpath,
     });
     expect(r.collectionsAdded).toEqual([]);
@@ -156,7 +156,7 @@ describe("reindexAfterSync", () => {
       acquireReindexLock: noLock,
       existsSync: () => true,
       readCompanies: () => ["acme"],
-      hasIndexableMarkdown: () => true,
+      hasIndexableMarkdown: (p) => p === path.join("/hq", "companies", "acme", "knowledge"),
       realpathSync: identityRealpath,
       env: {},
       embed: true,
@@ -183,7 +183,7 @@ describe("reindexAfterSync", () => {
       acquireReindexLock: noLock,
       existsSync: () => true,
       readCompanies: () => ["acme"],
-      hasIndexableMarkdown: () => true,
+      hasIndexableMarkdown: (p) => p === path.join("/hq", "companies", "acme", "knowledge"),
       realpathSync: identityRealpath,
       env: { HQ_QMD_REPAIR_PATH_DRIFT: "1" },
       embed: true,
@@ -238,6 +238,184 @@ describe("reindexAfterSync", () => {
     expect(calls).toEqual([["status"], ["collection", "list"], ["update"]]);
   });
 
+  it("registers populated company projects with the shell name and mask", () => {
+    const { exec, calls } = fakeExec({ listStdout: "" });
+    const r = reindexAfterSync("/hq", {
+      exec,
+      acquireReindexLock: noLock,
+      existsSync: () => true,
+      readCompanies: () => ["acme"],
+      hasIndexableMarkdown: () => false,
+      hasIndexableProjectContent: () => true,
+    });
+
+    expect(r.collectionsAdded).toEqual(["acme-projects"]);
+    expect(calls).toEqual([
+      ["status"],
+      ["collection", "list"],
+      [
+        "collection",
+        "add",
+        path.join("/hq", "companies", "acme", "projects"),
+        "--name",
+        "acme-projects",
+        "--mask",
+        "**/*.{md,json}",
+      ],
+      ["context", "add", "qmd://acme-projects", "Project PRDs and documentation for acme."],
+      ["update"],
+    ]);
+  });
+
+  it("skips missing and empty company projects dirs", () => {
+    const { exec, calls } = fakeExec({ listStdout: "" });
+    const emptyProjects = path.join("/hq", "companies", "empty", "projects");
+    const r = reindexAfterSync("/hq", {
+      exec,
+      acquireReindexLock: noLock,
+      existsSync: (p) => p !== path.join("/hq", "companies", "missing", "projects"),
+      readCompanies: () => ["missing", "empty"],
+      hasIndexableMarkdown: () => false,
+      hasIndexableProjectContent: (p) => p !== emptyProjects,
+    });
+
+    expect(r.collectionsAdded).toEqual([]);
+    expect(calls).toEqual([["status"], ["collection", "list"], ["update"]]);
+  });
+
+  it("registers populated personal knowledge with the shell name and mask", () => {
+    const { exec, calls } = fakeExec({ listStdout: "" });
+    const personalKnowledge = path.join("/hq", "personal", "knowledge");
+    const r = reindexAfterSync("/hq", {
+      exec,
+      acquireReindexLock: noLock,
+      existsSync: () => true,
+      readCompanies: () => [],
+      hasIndexableMarkdown: (p) => p === personalKnowledge,
+    });
+
+    expect(r.collectionsAdded).toEqual(["personal-knowledge"]);
+    expect(calls).toEqual([
+      ["status"],
+      ["collection", "list"],
+      [
+        "collection",
+        "add",
+        personalKnowledge,
+        "--name",
+        "personal-knowledge",
+        "--mask",
+        "**/*.md",
+      ],
+      ["context", "add", "qmd://personal-knowledge", "Personal knowledge base (owner overlay)."],
+      ["update"],
+    ]);
+  });
+
+  it("skips absent and empty personal knowledge", () => {
+    const absent = fakeExec({ listStdout: "" });
+    const absentResult = reindexAfterSync("/hq", {
+      exec: absent.exec,
+      acquireReindexLock: noLock,
+      existsSync: (p) => p !== path.join("/hq", "personal", "knowledge"),
+      readCompanies: () => [],
+    });
+    expect(absentResult.collectionsAdded).toEqual([]);
+    expect(absent.calls).toEqual([["status"], ["collection", "list"], ["update"]]);
+
+    const empty = fakeExec({ listStdout: "" });
+    const emptyResult = reindexAfterSync("/hq", {
+      exec: empty.exec,
+      acquireReindexLock: noLock,
+      existsSync: () => true,
+      readCompanies: () => [],
+      hasIndexableMarkdown: () => false,
+    });
+    expect(emptyResult.collectionsAdded).toEqual([]);
+    expect(empty.calls).toEqual([["status"], ["collection", "list"], ["update"]]);
+  });
+
+  it("does not add projects or personal knowledge a second time", () => {
+    let listCount = 0;
+    const { exec, calls } = fakeExec({
+      resultFor: (args) => {
+        if (args[0] !== "collection" || args[1] !== "list") return undefined;
+        listCount++;
+        return {
+          status: 0,
+          stdout:
+            listCount === 1
+              ? ""
+              : "acme (qmd://acme/)\nacme-projects (qmd://acme-projects/)\npersonal-knowledge (qmd://personal-knowledge/)\n",
+        };
+      },
+    });
+    const options = {
+      exec,
+      acquireReindexLock: noLock,
+      existsSync: () => true,
+      readCompanies: () => ["acme"],
+      hasIndexableMarkdown: () => true,
+      hasIndexableProjectContent: () => true,
+      realpathSync: identityRealpath,
+    };
+
+    expect(reindexAfterSync("/hq", options).collectionsAdded).toEqual([
+      "acme",
+      "acme-projects",
+      "personal-knowledge",
+    ]);
+    expect(reindexAfterSync("/hq", options).collectionsAdded).toEqual([]);
+    expect(calls.filter((c) => c[0] === "collection" && c[1] === "add")).toHaveLength(3);
+  });
+
+  it("emits the same collection-add commands as the shell for a fixture tree", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-qmd-parity-"));
+    try {
+      const hq = path.join(dir, "hq");
+      const acmeKnowledge = path.join(hq, "companies", "acme", "knowledge");
+      const acmeProjects = path.join(hq, "companies", "acme", "projects");
+      const emptyProjects = path.join(hq, "companies", "empty", "projects");
+      const personalKnowledge = path.join(hq, "personal", "knowledge");
+      fs.mkdirSync(path.join(hq, "core"), { recursive: true });
+      fs.mkdirSync(acmeKnowledge, { recursive: true });
+      fs.mkdirSync(acmeProjects, { recursive: true });
+      fs.mkdirSync(emptyProjects, { recursive: true });
+      fs.mkdirSync(personalKnowledge, { recursive: true });
+      fs.writeFileSync(path.join(hq, "core", "core.yaml"), "hqVersion: 1\n");
+      fs.writeFileSync(path.join(acmeKnowledge, "note.md"), "# knowledge\n");
+      fs.writeFileSync(path.join(acmeProjects, "prd.json"), "{}\n");
+      fs.writeFileSync(path.join(personalKnowledge, "note.md"), "# personal\n");
+
+      const { exec, calls } = fakeExec({ listStdout: "" });
+      reindexAfterSync(hq, { exec, acquireReindexLock: noLock });
+
+      expect(calls.filter((c) => c[0] === "collection" && c[1] === "add")).toEqual([
+        ["collection", "add", acmeKnowledge, "--name", "acme", "--mask", "**/*.md"],
+        [
+          "collection",
+          "add",
+          acmeProjects,
+          "--name",
+          "acme-projects",
+          "--mask",
+          "**/*.{md,json}",
+        ],
+        [
+          "collection",
+          "add",
+          personalKnowledge,
+          "--name",
+          "personal-knowledge",
+          "--mask",
+          "**/*.md",
+        ],
+      ]);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   it("skips qmd entirely when provided changed paths do not touch knowledge markdown", () => {
     const { exec, calls } = fakeExec({ listStdout: "" });
     const r = reindexAfterSync("/hq", {
@@ -262,7 +440,7 @@ describe("reindexAfterSync", () => {
         acquireReindexLock: noLock,
         existsSync: () => true,
         readCompanies: () => ["acme"],
-        hasIndexableMarkdown: () => true,
+        hasIndexableMarkdown: (p) => p === path.join("/hq", "companies", "acme", "knowledge"),
         changedPaths: ["companies/acme/knowledge/note.md"],
         debounceMs: 60_000,
         nowMs: 100_000,

package/src/qmd-reindex.ts

@@ -15,9 +15,10 @@
  * script inside the synced HQ tree (which may be stale).
  *
  * What it does, best-effort and idempotent:
- *   1. Auto-registers any `companies/<slug>/knowledge` dir that isn't yet a
- *      qmd collection (kills the manual "map" step). Detects path drift when
- *      the name exists but points elsewhere; repairs only when
+ *   1. Auto-registers populated company knowledge, company project, and
+ *      personal knowledge dirs that aren't yet qmd collections (kills the
+ *      manual "map" step). Company knowledge detects path drift when the name
+ *      exists but points elsewhere; repairs only when
  *      `HQ_QMD_REPAIR_PATH_DRIFT=1` (non-breaking default: detect-only).
  *   2. Runs an incremental lexical `qmd update` (fast — qmd skips unchanged
  *      files by mtime).
@@ -395,6 +396,8 @@ export interface ReindexOptions {
   readCompanies?: (companiesDir: string) => string[];
   /** Returns true if the knowledge dir has at least one indexable .md file. */
   hasIndexableMarkdown?: (knowledgeDir: string) => boolean;
+  /** Returns true if the projects dir has at least one indexable .md or .json file. */
+  hasIndexableProjectContent?: (projectsDir: string) => boolean;
   /** Reindex-lock acquirer override for tests. */
   acquireReindexLock?: AcquireReindexLock;
   /** Corrupt-index quarantine override for tests. */
@@ -474,7 +477,7 @@ export function reindexAfterSync(
     const changedPaths = opts.changedPaths;
     const dirtyFromChanges =
       changedPaths === undefined ||
-      changedPaths.some(isKnowledgeMarkdownPath);
+      changedPaths.some(isQmdIndexableContentPath);
     const registrationMayBeStale =
       opts.forceCollectionRefresh === true ||
       changedPaths === undefined ||
@@ -528,6 +531,9 @@ export function reindexAfterSync(
       result.qmdAvailable = true;
       const existingCollections = list.stdout;
       let repairedThisCycle = false;
+      const hasIndexableMarkdown = opts.hasIndexableMarkdown ?? defaultHasIndexableMarkdown;
+      const hasIndexableProjectContent =
+        opts.hasIndexableProjectContent ?? defaultHasIndexableProjectContent;
 
       // 1. Auto-register missing / reconcile drifted company knowledge collections.
       if (registrationMayBeStale) {
@@ -537,7 +543,7 @@ export function reindexAfterSync(
         for (const slug of slugs) {
           const knowledgeDir = path.join(companiesDir, slug, "knowledge");
           if (!existsSync(knowledgeDir)) continue;
-          const hasMd = (opts.hasIndexableMarkdown ?? defaultHasIndexableMarkdown)(knowledgeDir);
+          const hasMd = hasIndexableMarkdown(knowledgeDir);
           if (!hasMd) continue;
 
           const namePresent = existingCollections.includes(`qmd://${slug}/`);
@@ -601,6 +607,58 @@ export function reindexAfterSync(
           result.collectionsRepaired.push(slug);
           repairedThisCycle = true;
         }
+
+        // 1b. Auto-register company projects collections. Match the shell
+        // post-sync convention exactly so prd.json and project docs are searchable.
+        for (const slug of slugs) {
+          const projectsDir = path.join(companiesDir, slug, "projects");
+          if (!existsSync(projectsDir)) continue;
+          if (!hasIndexableProjectContent(projectsDir)) continue;
+
+          const name = `${slug}-projects`;
+          if (existingCollections.includes(`qmd://${name}/`)) continue;
+          const add = exec([
+            "collection",
+            "add",
+            projectsDir,
+            "--name",
+            name,
+            "--mask",
+            "**/*.{md,json}",
+          ]);
+          if (add.status === 0) {
+            exec(["context", "add", `qmd://${name}`, `Project PRDs and documentation for ${slug}.`]);
+            result.collectionsAdded.push(name);
+          }
+        }
+
+        // 1c. Auto-register the owner overlay's personal knowledge collection.
+        const personalKnowledgeDir = path.join(hqRoot, "personal", "knowledge");
+        const personalKnowledgeName = "personal-knowledge";
+        if (
+          existsSync(personalKnowledgeDir) &&
+          hasIndexableMarkdown(personalKnowledgeDir) &&
+          !existingCollections.includes(`qmd://${personalKnowledgeName}/`)
+        ) {
+          const add = exec([
+            "collection",
+            "add",
+            personalKnowledgeDir,
+            "--name",
+            personalKnowledgeName,
+            "--mask",
+            "**/*.md",
+          ]);
+          if (add.status === 0) {
+            exec([
+              "context",
+              "add",
+              `qmd://${personalKnowledgeName}`,
+              "Personal knowledge base (owner overlay).",
+            ]);
+            result.collectionsAdded.push(personalKnowledgeName);
+          }
+        }
       }
 
       // 2. Incremental lexical reindex.
@@ -721,9 +779,13 @@ function writeState(statePath: string, state: QmdReindexState): void {
   }
 }
 
-function isKnowledgeMarkdownPath(relPath: string): boolean {
+function isQmdIndexableContentPath(relPath: string): boolean {
   const normalized = relPath.split(path.sep).join("/");
-  return /^companies\/[^/]+\/knowledge\/.+\.md$/i.test(normalized);
+  return (
+    /^companies\/[^/]+\/knowledge\/.+\.md$/i.test(normalized) ||
+    /^companies\/[^/]+\/projects\/.+\.(?:md|json)$/i.test(normalized) ||
+    /^personal\/knowledge\/.+\.md$/i.test(normalized)
+  );
 }
 
 function defaultReadCompanies(companiesDir: string): string[] {
@@ -758,3 +820,23 @@ function defaultHasIndexableMarkdown(knowledgeDir: string): boolean {
   }
   return false;
 }
+
+function defaultHasIndexableProjectContent(projectsDir: string): boolean {
+  // Match the shell's `find -type f \( -name '*.md' -o -name '*.json' \)`
+  // guard: project documentation and PRD JSON both make the collection useful.
+  const stack = [projectsDir];
+  while (stack.length) {
+    const dir = stack.pop()!;
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (e.isFile() && (e.name.endsWith(".md") || e.name.endsWith(".json"))) return true;
+      if (e.isDirectory()) stack.push(path.join(dir, e.name));
+    }
+  }
+  return false;
+}

package/src/telemetry.test.ts

@@ -978,6 +978,35 @@ describe("collectAndSendTelemetry — companyUid attribution", () => {
     expect("companyUid" in client.posts[0].events[0]).toBe(false);
   });
 
+  it("uses the explicit single-company fallback when cwd is the shared HQ root", async () => {
+    const client = makeClient();
+    writeJsonl(env, "proj", "s.jsonl", [rowWithCwd("u1", hqRoot)]);
+
+    await collectAndSendTelemetry({
+      ...makeOpts(env, client),
+      hqRoot,
+      fallbackCompany: "indigo",
+    });
+
+    expect(client.posts).toHaveLength(1);
+    expect(client.posts[0].events[0].companyUid).toBe(COMPANY_UID);
+  });
+
+  it("prefers the cwd-resolved company over the single-company fallback", async () => {
+    const client = makeClient();
+    const inRepo = path.join(hqRoot, "repos/private/hq-cloud");
+    writeJsonl(env, "proj", "s.jsonl", [rowWithCwd("u1", inRepo)]);
+
+    await collectAndSendTelemetry({
+      ...makeOpts(env, client),
+      hqRoot,
+      fallbackCompany: "cmp_01OTHER",
+    });
+
+    expect(client.posts).toHaveLength(1);
+    expect(client.posts[0].events[0].companyUid).toBe(COMPANY_UID);
+  });
+
   it("never sends the reserved 'unattributed' value", async () => {
     const client = makeClient();
     writeJsonl(env, "proj", "s.jsonl", [

package/src/telemetry.ts

@@ -73,6 +73,12 @@ export interface CollectTelemetryOptions {
    * server treats the event as unattributed/personal.
    */
   hqRoot?: string;
+  /**
+   * Explicit single-company sync scope (`--company <slug-or-uid>`). Used only
+   * when an event cwd does not resolve through the manifest. This is intentionally
+   * absent for multi-company and personal runs to prevent cross-tenant attribution.
+   */
+  fallbackCompany?: string;
   /** Override `~/.claude/projects` for tests. */
   claudeProjectsRoot?: string;
   /** Override `~/.codex` for tests. Both live and archived rollouts are scanned. */
@@ -687,6 +693,11 @@ export async function collectAndSendTelemetry(
   const repoCompanyMap: RepoCompanyMap = opts.hqRoot
     ? await buildRepoCompanyMap(opts.hqRoot)
     : { entries: [], bySlug: new Map(), foldsCase: false, ambiguous: new Set<string>() };
+  const fallbackCompanyUid = opts.fallbackCompany?.startsWith("cmp_")
+    ? opts.fallbackCompany
+    : opts.fallbackCompany
+      ? repoCompanyMap.bySlug.get(opts.fallbackCompany)
+      : undefined;
 
   // 1. Opt-in check (server-authoritative, with local fallback + self-heal).
   let enabled: boolean;
@@ -1012,10 +1023,11 @@ export async function collectAndSendTelemetry(
         sourceRow && typeof sourceRow === "object" && !Array.isArray(sourceRow)
           ? (sourceRow as Record<string, unknown>).cwd
           : undefined;
-      const companyUid = resolveCompanyForCwd(
-        typeof rowCwd === "string" ? rowCwd : undefined,
-        repoCompanyMap,
-      );
+      const companyUid =
+        resolveCompanyForCwd(
+          typeof rowCwd === "string" ? rowCwd : undefined,
+          repoCompanyMap,
+        ) ?? fallbackCompanyUid;
       const sanitized = sanitizeRow(sourceRow, companyUid);
       if (!sanitized) {
         batchSources.push(source());