fix(coding-agents): tolerate hidden page triggers (#3742)

Treat an omitted page trigger as unknown rather than drift.
Avoid trigger-only PATCH requests to older servers that reject the field.
Continue reconciling source-query changes and explicit trigger drift.
Document the unknown-trigger behavior and add regression coverage.

Author: Sanderhoff-alt

hindsight-integrations/coding-agents/src/core/hindsight.pages.test.ts

@@ -286,7 +286,6 @@ describe("HindsightClient.seedPages", () => {
     expect(patches[0].body).toEqual({
       source_query: drifted.source_query,
       tags: drifted.tags,
-      trigger: buildPageTrigger(),
     });
   });
 
@@ -321,10 +320,9 @@ describe("HindsightClient.seedPages", () => {
     }
   });
 
-  // The common case in the field: a server older than #3572 reports no trigger at all, so the
-  // policy is unknowable and gets re-sent. Cheap, idempotent, and self-healing once the server
-  // starts answering — but it must still be trigger-ONLY, or every run rebuilds all five pages.
-  it("re-sends the trigger to a server that does not report one", async () => {
+  // A server older than #3572 does not report a page's trigger. That makes the policy unknowable,
+  // not divergent; sending a trigger-only PATCH would be rejected by servers older than #3549.
+  it("does not write when a server does not report a trigger", async () => {
     const calls: any[] = [];
     stubFetchRouted(calls, [
       {
@@ -342,9 +340,35 @@ describe("HindsightClient.seedPages", () => {
     const c = new HindsightClient({ apiUrl: "http://x", bank: "repo-a" });
     await c.seedPages();
 
+    expect(calls).toHaveLength(1); // the tree GET only
+    expect(calls.every((k) => k.method === "GET")).toBe(true);
+  });
+
+  it("still reconciles source-query drift when the server hides trigger", async () => {
+    const calls: any[] = [];
+    const drifted = PAGES[0];
+    stubFetchRouted(calls, [
+      {
+        match: (m, u) => m === "GET" && u.endsWith("/knowledge-base/tree"),
+        json: {
+          roots: PAGES.map((p, i) => ({
+            id: `kp-${i}`,
+            kind: "page",
+            name: p.name,
+            description: p === drifted ? "an older wording of the query" : p.source_query,
+          })),
+        },
+      },
+    ]);
+    const c = new HindsightClient({ apiUrl: "http://x", bank: "repo-a" });
+    await c.seedPages();
+
     const patches = calls.filter((k) => k.method === "PATCH");
-    expect(patches).toHaveLength(PAGES.length);
-    for (const patch of patches) expect(patch.body).toEqual({ trigger: buildPageTrigger() });
+    expect(patches).toHaveLength(1);
+    expect(patches[0].body).toEqual({
+      source_query: drifted.source_query,
+      tags: drifted.tags,
+    });
   });
 
   it("names the repository in every seeded query, so synthesis can exclude a dependency's facts", async () => {

hindsight-integrations/coding-agents/src/core/hindsight.ts

@@ -24,7 +24,7 @@ export interface KnowledgeNode {
   /** The page's source query (OKF `description`) — what a re-sync compares against. */
   description?: string;
   /** The page's EFFECTIVE refresh policy, on servers new enough to report it (#3572). Absent
-   *  everywhere else, which `seedPages()` reads as "unknown, re-send it". */
+   *  everywhere else, which `seedPages()` reads as "unknown, leave it alone". */
   trigger?: { tags_match?: string };
   children?: KnowledgeNode[];
 }
@@ -618,23 +618,24 @@ export class HindsightClient {
           return;
         }
         if (r.status !== 409) created++;
-      } else if (
-        hit.description !== page.source_query ||
-        hit.trigger?.tags_match !== pageTrigger.tags_match
-      ) {
+      } else {
+        const sourceDrift = hit.description !== page.source_query;
+        // Older servers omit trigger from the tree, so an absent value means unknown rather
+        // than drift. Those servers also reject a trigger-only PATCH as an empty update.
+        const triggerDrift =
+          hit.trigger != null && hit.trigger.tags_match !== pageTrigger.tags_match;
+        if (!sourceDrift && !triggerDrift) continue;
+
         // The name IS the match key, so it can't drift; the source query and the trigger can.
-        // The trigger is re-sent because it is the only way a policy change reaches a page that
-        // already exists — `tags_match` (see PAGE_TAGS_MATCH) is a fix every previously seeded
-        // page needs, and a `pageTriggerType` change never reached one either. Servers that don't
-        // report a page's trigger on the tree yet answer "unknown" and get it re-sent every run:
-        // the PATCH is idempotent and schedules no refresh unless the source query also changed.
-        const patch: { trigger: PageTrigger; source_query?: string; tags?: string[] } = {
-          trigger: pageTrigger,
-        };
-        if (hit.description !== page.source_query) {
+        // The trigger is re-sent when the server reports it drifting, because it is the only way
+        // a policy change reaches a page that already exists. Servers that do not report a page's
+        // trigger leave its policy unknown; source-query drift can still be reconciled safely.
+        const patch: { trigger?: PageTrigger; source_query?: string; tags?: string[] } = {};
+        if (sourceDrift) {
           patch.source_query = page.source_query;
           patch.tags = page.tags;
         }
+        if (triggerDrift) patch.trigger = pageTrigger;
         const r = await this.req(
           "PATCH",
           this.bankUrl(`/knowledge-base/nodes/${encodeURIComponent(hit.id)}`),