@inerrata-corporation/errata 2.0.0-dev.76 → 2.0.0-dev.78

package/errata.mjs

@@ -20899,6 +20899,11 @@ function toWirePayload(batch, runId) {
     // Origin key (= project) for the refute channel's cross-origin gate; absent
     // for id-less batches (principle sync) → those nodes stay fail-open.
     ...batch.originProject ? { originProject: batch.originProject } : {},
+    // PJ-write (§5a): the AUDIENCE assertion — which project stratum this batch is
+    // contributed to. Verified server-side against the projected link record; an
+    // unverifiable assertion rejects the whole batch rather than downgrading it to a
+    // wider audience. Absent ⇒ exactly today's wire.
+    ...batch.projectId ? { projectId: batch.projectId } : {},
     nodes,
     edges,
     ...symbolSummaries ? { symbolSummaries } : {}
@@ -21145,6 +21150,18 @@ var init_client = __esm({
       async attachProject(projectId, locator) {
         return this.json("POST", "/api/gate/projects/attach", { projectId, locator });
       }
+      /** Fetch the project's symbol salt (PJ-anchors · plan §6c) — the HMAC key this
+       *  workspace needs to derive project-canonical `sym_` anchor ids that CONVERGE
+       *  with every other member's.
+       *
+       *  Members-only: the server gates it with the same fail-closed check the ingest
+       *  door uses (known + active + owned by the caller's org), and 403s otherwise.
+       *  Safe to hold locally for exactly one reason — a project member can already read
+       *  the project's code, so the salt lets them compute ids for symbols they can see
+       *  anyway. It is key material: keep it in memory, never log it. */
+      async projectSymbolSalt(projectId) {
+        return this.json("GET", `/v2/projects/${encodeURIComponent(projectId)}/symbol-salt`);
+      }
       /** Create a locator-less project — `errata link --name` for repos without a
        *  usable remote. Discovery can't find it; the caller stamps the id locally. */
       async createProject(name2) {
@@ -21336,6 +21353,16 @@ var init_client = __esm({
         if (q.seed?.length) qs.set("seed", q.seed.join(","));
         if (q.q) qs.set("q", q.q);
         const res = await this.json("GET", `/v2/search?${qs.toString()}`);
+        const { nodes, edges } = this.toCastalia(res);
+        return { nodes, edges, generatedAt: res.generatedAt };
+      }
+      /**
+       * The castalia wire shape → local-mergeable graph. Extracted so the priming fetch
+       * (`getProjectPriors`) lands nodes through the EXACT same mapper as `search`: a
+       * second mapper would be a second convergence-key convention to keep in sync, and
+       * an id-keying drift between the two is a silent no-op, not a crash.
+       */
+      toCastalia(res) {
         const now = Date.now();
         const nodes = res.nodes.map((n) => ({
           id: n.canonicalId,
@@ -21369,7 +21396,25 @@ var init_client = __esm({
           navFailures: 0,
           attrs: { ...e.attrs, source: "cloud" }
         }));
-        return { nodes, edges, generatedAt: res.generatedAt };
+        return { nodes, edges };
+      }
+      /**
+       * PJ-hydrate: the one-time seeded prime a fresh clone pulls at attach.
+       *
+       * A clone can already READ its project stratum (query-time federation, PJ-read) —
+       * what it can't do is PRIME, because the passive block builds from the local store
+       * and the remote blend is seeded from local problems a new checkout doesn't have.
+       * This lands the top of the stratum locally so both have something to stand on.
+       *
+       * Membership-gated server-side by the same fail-closed check as ingest: a caller
+       * who couldn't write this project's stratum can't prime from it.
+       */
+      async getProjectPriors(projectId, limit = 50) {
+        const res = await this.json(
+          "GET",
+          `/v2/projects/${encodeURIComponent(projectId)}/priors?limit=${String(limit)}`
+        );
+        return this.toCastalia(res);
       }
       /** Pull cloud-induced skills + the session-bootstrap prime payload. `seed` is the
        *  canonical ids of the agent's recent problems — the cloud ranks the skills whose
@@ -43276,7 +43321,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.0-dev.76" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.0-dev.78" : "2.0.0-alpha.0";
 var IGNORED_PATH = /[\\/](?:\.git|node_modules|\.errata|\.claude|\.codex|\.cursor|\.turbo|\.next|dist|coverage|test-results|playwright-report|__pycache__)(?:[\\/]|$)/;
 var IGNORED_NOISE = /castalia\.db|eventlog\.sqlite|turn-cursors/;
 var GIT_OP_MUTE_MS = 4e3;
@@ -45005,6 +45050,7 @@ function runLockfilePass(opts) {
 init_src();
 init_src2();
 init_src8();
+init_src();
 
 // src/contribution-ready.ts
 init_src3();
@@ -45143,6 +45189,50 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
       contextNodes.push(shareableContext(t, wireId));
     }
   }
+  const project = opts.project;
+  if (project) {
+    const now = Date.now();
+    for (const sourceId of anchorSources) {
+      const source = store.getNode(sourceId);
+      if (!source) continue;
+      for (const e of store.outEdges(sourceId, ["ANCHORED_AT"])) {
+        const target = store.getNode(e.to);
+        if (!target) continue;
+        const relPath = target.attrs["relPath"];
+        const qname = target.attrs["qname"];
+        if (typeof relPath !== "string" || typeof qname !== "string") continue;
+        if (ignored(relPath) || ignored(qname)) continue;
+        const symId = projectSymbolId(project.salt, project.projectId, relPath, qname, target.label);
+        if (!contextSeen.has(symId)) {
+          contextSeen.add(symId);
+          contextNodes.push({
+            id: symId,
+            label: "Symbol",
+            // The id IS the description: there is nothing that can be said about an
+            // opaque symbol without disclosing it, and the wire requires a non-empty
+            // string. It must never carry the name or the path.
+            description: symId,
+            // `kind` is coarse (Function/Class/…) — shape, not identity.
+            attrs: { kind: target.label },
+            embedding: [],
+            extractionConfidence: 1,
+            extractionSource: "daemon-extracted",
+            cumulativeSurprise: 0,
+            peakSurprise: 0,
+            cumulativeHits: 0,
+            lastUpdatedAt: now,
+            createdAt: now,
+            memoryTier: "short-term",
+            pageRank: 0,
+            isLandmark: false,
+            community: null,
+            stability: "unstable"
+          });
+        }
+        anchorEdges.push({ ...e, to: symId, attrs: {} });
+      }
+    }
+  }
   if (nodes.length === 0 && anchorEdges.length === 0) return null;
   let symbolSummaries;
   if (opts.lexicon && opts.lexicon.size > 0 && nodes.length > 0) {
@@ -45401,6 +45491,39 @@ async function ensureProjectLink(root, profile, client) {
   }
 }
 
+// src/project-hydrate.ts
+var DEFAULT_LIMIT = 50;
+async function hydrateProject(opts) {
+  const { root, profile, store, cloud } = opts;
+  if (!profile.projectId) return { hydrated: false, reason: "no-project" };
+  if (profile.projectHydratedAt) return { hydrated: false, reason: "already-hydrated" };
+  try {
+    const res = await cloud.getProjectPriors(profile.projectId, opts.limit ?? DEFAULT_LIMIT);
+    let landedNodes = 0;
+    for (const n of res.nodes) {
+      if (store.getNode(n.id)) continue;
+      store.mergeNode(n);
+      landedNodes++;
+    }
+    let landedEdges = 0;
+    for (const e of res.edges) {
+      if (!store.getNode(e.from) || !store.getNode(e.to)) continue;
+      if (store.getEdge(e.id)) continue;
+      store.mergeEdge(e);
+      landedEdges++;
+    }
+    profile.projectHydratedAt = Date.now();
+    saveProfile(root, profile);
+    return { hydrated: true, nodes: landedNodes, edges: landedEdges };
+  } catch (err2) {
+    return {
+      hydrated: false,
+      reason: "error",
+      detail: err2 instanceof Error ? err2.message : String(err2)
+    };
+  }
+}
+
 // src/adopt.ts
 import { existsSync as existsSync22 } from "node:fs";
 import { dirname as dirname8, join as join25 } from "node:path";
@@ -45444,6 +45567,14 @@ function createRootAdopter(deps) {
 }
 
 // src/multi.ts
+var projectSymbolSalts = /* @__PURE__ */ new Map();
+async function resolveProjectSymbolSalt(client, projectId) {
+  const cached2 = projectSymbolSalts.get(projectId);
+  if (cached2) return { projectId, salt: cached2 };
+  const { salt } = await client.projectSymbolSalt(projectId);
+  projectSymbolSalts.set(projectId, salt);
+  return { projectId, salt };
+}
 function normPath(p) {
   return p.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
 }
@@ -45834,6 +45965,20 @@ async function startMultiDaemon(opts = {}) {
       } else if (out2.reason === "error") {
         console.warn(`[errata] project link failed for ${r.engine.profile.name}: ${out2.detail}`);
       }
+      const hyd = await hydrateProject({
+        root: r.root,
+        profile: r.engine.profile,
+        store: r.engine.store,
+        cloud: client
+      });
+      if (hyd.hydrated) {
+        r.engine.markContextDirty();
+        console.log(
+          `[errata] primed ${r.engine.profile.name} from project \u2014 ${hyd.nodes} priors, ${hyd.edges} links`
+        );
+      } else if (hyd.reason === "error") {
+        console.warn(`[errata] project prime failed for ${r.engine.profile.name}: ${hyd.detail}`);
+      }
     }
   };
   void ambientLinkAll();
@@ -46052,11 +46197,21 @@ async function startMultiDaemon(opts = {}) {
           if (summaries.size > 0) lexicon = buildSymbolLexicon(store, summaries);
         } catch {
         }
+        const projectId = r.engine.profile.projectId;
+        let project;
+        if (projectId) {
+          try {
+            project = await resolveProjectSymbolSalt(client, projectId);
+          } catch {
+          }
+        }
         const instances = buildInstanceIngest(store, r.engine.profile, DAEMON_VERSION, ignore, {
           includePackages: cfg2.consent.contributePackages,
-          ...lexicon ? { lexicon } : {}
+          ...lexicon ? { lexicon } : {},
+          ...project ? { project } : {}
         });
         if (instances) {
+          if (project) instances.projectId = project.projectId;
           const res = await client.ingest(instances);
           uploaded += res.accepted;
           const seq = store.currentIngestSeq();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata-corporation/errata",
-  "version": "2.0.0-dev.76",
+  "version": "2.0.0-dev.78",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {