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

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) {
@@ -43276,7 +43293,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.77" : "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 +45022,7 @@ function runLockfilePass(opts) {
 init_src();
 init_src2();
 init_src8();
+init_src();
 
 // src/contribution-ready.ts
 init_src3();
@@ -45143,6 +45161,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) {
@@ -45444,6 +45506,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();
 }
@@ -46052,11 +46122,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.77",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {