granttap-mcp 0.8.20 → 0.8.22

package/README.md

@@ -80,12 +80,34 @@ separate from their path identity. Missing content evidence remains unknown.
 
 <p align="center">
   <img src="docs/images/iphone-projects-shared.png" width="200" alt="Projects: one owned by this phone, one shared by another">
+  <img src="docs/images/iphone-linked-projects.png" width="200" alt="Two linked Projects with separate access scopes">
   <img src="docs/images/iphone-project-mesh.png" width="200" alt="A Project: Governance, members and computers, Mesh status, repositories, Tasks">
   <img src="docs/images/iphone-task-route.png" width="200" alt="A Task: executions, Runtime history, and resource claims">
   <img src="docs/images/iphone-handoff.png" width="200" alt="Task handoff: destination, push, and readiness checks">
 </p>
 
-<p align="center"><em>Projects, one of them shared by another phone · a Project with its Governance, members, computers, repositories, and Tasks · a Task with executions, Runtime history, and claims · a handoff with its readiness checks</em></p>
+<p align="center"><em>Shared Projects · linked repository bindings with separate Project access · Project management · Task execution history · handoff readiness</em></p>
+
+<p align="center">
+  <img src="docs/images/iphone-weavatrix-graph.png" width="200" alt="Full-screen architecture graph with sample evidence">
+  <img src="docs/images/iphone-health-code-towers.png" width="200" alt="Full-screen Health code towers with sample evidence">
+</p>
+
+<p align="center"><em>These are deterministic simulator fixtures, not reports from a live customer repository.</em></p>
+
+An authenticated controller can request a separate, one-time device credential
+for another iPhone or iPad from each Live linked computer. The phone packages
+the resulting links in an encrypted, single-use QR. This adds the new phone to
+the same device network; it does not grant Project membership. Explicit human
+decisions for a bound Project Task can be recorded through Engine Memory, and
+a same-scope correction supersedes an earlier decision while retaining history.
+The computer returns `recorded` only after the Engine confirms storage.
+
+The capability catalog distinguishes local observations from installed and
+initialized state. It does not yet transfer and apply complete MCP or skill
+bundles to every host. Usage figures do not enforce spending caps. Project
+Environment secrets injected into an agent process remain readable by that
+process; a use-only credential broker is not part of this runtime yet.
 
 For Claude Code, Codex, and Cursor, the provider hook runs inside the agent's
 own session and sees the exact call. GrantTap attributes every `notify` to the

package/apps/bridge/src/bin/runtime/monitor.ts

@@ -3,6 +3,8 @@ import { join } from "node:path";
 import { RelayClient } from "../../../../../packages/core/relay-client";
 import { configDir, loadConfig, machineConfigPath } from "../../config";
 import { EngineSupervisor } from "../../engine/runtime/engine-supervisor";
+import { meshSnapshots } from "../../mesh/runtime";
+import { recoverLocalGraphBindings } from "../../mesh/runtime/graph/binding-sync";
 import { startSessionMonitor } from "../../monitor";
 import { controllerPeerGate } from "../../pairing/controllers";
 
@@ -38,6 +40,13 @@ process.on("SIGINT", stop);
 process.on("SIGTERM", stop);
 
 void engine.ensureAvailable().then((health) => {
+  if (health.state === "healthy") {
+    // A new Engine binary starts with its own registry. Re-admit existing,
+    // locally verified Git bindings so linked repositories have a graph again.
+    void recoverLocalGraphBindings(meshSnapshots())
+      .then(() => monitor.publish())
+      .catch(() => undefined);
+  }
   if (health.state !== "disabled" && health.state !== "healthy") {
     const reason = health.reason ? `: ${health.reason}` : "";
     process.stderr.write(

package/apps/bridge/src/capabilities/README.md

@@ -2,4 +2,9 @@
 
 This module discovers provider-configured MCP servers and available skills. Metadata probing is isolated because it may start an MCP transport; local descriptors and skill discovery remain read-only.
 
+Skill digests cover the bounded bundle, including scripts and references.
+Catalog observations and Project requests do not install a skill or native MCP
+configuration on another host. Availability requires a separate native apply
+and independently observed initialization; that rollout is still unfinished.
+
 License: this module is distributed under the MIT License in the repository-root `LICENSE` file.

package/apps/bridge/src/cortex/integration.ts

@@ -14,6 +14,7 @@ import type { ScopedMeshView } from "../mesh/snapshot/scoped-view";
 import { loadRuntimeConfig } from "../config/runtime";
 import { computerId } from "../mesh/identity/computer";
 import { defaultCortexConfig } from "./config";
+import { activeProjectKnowledge, activeScopedKnowledge, unrecordedKnowledgeEvents } from "../mesh/knowledge/active";
 
 type CortexDependencies = {
   provenance?: typeof projectEngineProvenance;
@@ -109,15 +110,16 @@ export function cortexSnapshotEvidence(
     `repository.${graph.repositoryId}`, "weavatrix.repository", JSON.stringify(graph),
     "high", "verified", "graph", graph.revision,
   ));
-  const knowledge = (snapshot.knowledge ?? []).filter((record) =>
+  const knowledge = activeProjectKnowledge(snapshot.projectId, snapshot.knowledge ?? []).filter((record) =>
     record.taskId === taskId || record.visibility === "project").slice(0, 16);
   for (const record of knowledge) evidence.push(item(
     `knowledge.${record.recordId}`, "weavatrix.memory", JSON.stringify(record),
     "high", "unverified", "memory", `memory:${record.streamVersion}`,
   ));
-  const recorded = new Set(knowledge.map((record) => record.sourceRef));
-  for (const event of snapshot.events.filter((value) => value.taskId === taskId
-    && !recorded.has(value.eventId)).slice(-32)) {
+  for (const event of unrecordedKnowledgeEvents(
+    snapshot.events.filter((value) => value.taskId === taskId),
+    snapshot.knowledge ?? [], snapshot.supersededKnowledgeRecordIds,
+  ).slice(-32)) {
     evidence.push(item(
       `event.${event.eventId}`, "mesh.event", JSON.stringify(event),
       "normal", "unverified", "memory", `event:${event.createdAt}`,
@@ -145,13 +147,14 @@ export function cortexScopedEvidence(view: ScopedMeshView): EngineContextEvidenc
     `repository.${graph.repositoryId}`, "weavatrix.repository", JSON.stringify(graph),
     "high", "verified", "graph", graph.revision,
   ));
-  const knowledge = (view.knowledge ?? []).slice(0, 16);
+  const knowledge = activeScopedKnowledge(view.project.projectId, view.knowledge ?? [], taskId).slice(0, 16);
   for (const record of knowledge) evidence.push(item(
     `knowledge.${record.recordId}`, "weavatrix.memory", JSON.stringify(record),
     "high", "unverified", "memory", `memory:${record.streamVersion}`,
   ));
-  const recorded = new Set(knowledge.map((record) => record.sourceRef));
-  for (const event of view.events.filter((value) => !recorded.has(value.eventId)).slice(-32)) evidence.push(item(
+  for (const event of unrecordedKnowledgeEvents(
+    view.events, view.knowledge ?? [], view.supersededKnowledgeRecordIds,
+  ).slice(-32)) evidence.push(item(
     `event.${event.eventId}`, "mesh.event", JSON.stringify(event),
     "normal", "unverified", "memory", `event:${event.createdAt}`,
   ));

package/apps/bridge/src/engine/protocol/engine-memory-protocol.ts

@@ -12,6 +12,7 @@ export type KnowledgeRecordInput = {
   visibility: KnowledgeVisibility;
   repository_id?: string | null;
   commit_sha?: string | null;
+  supersedes_record_id?: string | null;
   recorded_at: number;
 };
 
@@ -28,6 +29,7 @@ export type MemoryEngineOperation =
   | { operation: "memory.history"; input: {
     project_id: string; task_id?: string | null; visibility?: KnowledgeVisibility | null;
     before_version?: number | null; limit?: number | null;
+    include_superseded?: boolean;
   } };
 export type MemoryEngineResult =
   | { operation: "memory.recorded"; record_id: string; stream_version: number }
@@ -62,6 +64,7 @@ export function parseMemoryResult(result: Record<string, unknown>, invalid: () =
     if (entry.repository_id != null) bounded(entry.repository_id, 512, invalid);
     if (entry.commit_sha != null && (typeof entry.commit_sha !== "string"
       || !/^[0-9a-f]{7,64}$/i.test(entry.commit_sha))) invalid();
+    if (entry.supersedes_record_id != null) bounded(entry.supersedes_record_id, 128, invalid);
     integer(entry.recorded_at, invalid);
     integer(entry.stream_version, invalid);
   }

package/apps/bridge/src/engine/protocol/transport/protocol-types.ts

@@ -45,6 +45,16 @@ export type EngineRepositoryGraph = {
     status: "SUPPORTED" | "CANDIDATE" | "CONTRADICTED" | "INSUFFICIENT_EVIDENCE";
     evidence: string[]; contradictions: string[]; unknowns: string[];
   }>;
+  code_map?: {
+    files: Array<{ path: string; language: string | null; line_count: number | null;
+      symbols: Array<{ id: string; label: string; kind: string;
+        start_line: number; line_count: number }> }>;
+    externals?: Array<{ id: string; label: string; kind: string }>;
+    roads: Array<{ source: string; target: string; relation: string }>;
+    total_files: number;
+    total_externals?: number;
+    truncated: boolean;
+  } | null;
   nodes: Array<{ id: string; kind: string; label: string }>;
   relations: Array<{ source: string; target: string; relation: string; evidence_count?: number }>;
   total_nodes: number;

package/apps/bridge/src/engine/protocol/transport/result-parser.ts

@@ -148,6 +148,7 @@ function parseRepositoryGraph(value: unknown): void {
       }
     }
   }
+  if (graph.code_map != null) parseCodeMap(graph.code_map);
   if (!Array.isArray(graph.nodes) || graph.nodes.length > 256
     || !Array.isArray(graph.relations) || graph.relations.length > 512
     || !Number.isSafeInteger(graph.total_nodes) || Number(graph.total_nodes) < 0
@@ -170,6 +171,55 @@ function parseRepositoryGraph(value: unknown): void {
   }
 }
 
+function parseCodeMap(value: unknown): void {
+  const map = requireObject(value, "repository code map");
+  if (!Array.isArray(map.files) || map.files.length > 650
+    || (map.externals != null && (!Array.isArray(map.externals) || map.externals.length > 24))
+    || !Array.isArray(map.roads) || map.roads.length > 1_200
+    || !Number.isSafeInteger(map.total_files) || Number(map.total_files) < map.files.length
+    || (map.total_externals != null && !Number.isSafeInteger(map.total_externals))
+    || Number(map.total_externals ?? 0) < (Array.isArray(map.externals) ? map.externals.length : 0)
+    || typeof map.truncated !== "boolean") invalidResult();
+  const paths = new Set<string>();
+  for (const value of map.files) {
+    const file = requireObject(value, "repository code file");
+    requireBoundedString(file.path, "code path", 512);
+    const path = file.path as string;
+    if (path.startsWith("/") || path.split("/").includes("..") || paths.has(path)) invalidResult();
+    paths.add(path);
+    requireOptionalString(file.language, "code language", 64);
+    if (file.line_count != null
+      && (!Number.isSafeInteger(file.line_count) || Number(file.line_count) < 1)) invalidResult();
+    if (!Array.isArray(file.symbols) || file.symbols.length > 72) invalidResult();
+    for (const value of file.symbols) {
+      const symbol = requireObject(value, "code symbol");
+      requireBoundedString(symbol.id, "code symbol id", 512);
+      requireBoundedString(symbol.label, "code symbol label", 160);
+      requireBoundedString(symbol.kind, "code symbol kind", 64);
+      if (!Number.isSafeInteger(symbol.start_line) || Number(symbol.start_line) < 1
+        || !Number.isSafeInteger(symbol.line_count) || Number(symbol.line_count) < 1) invalidResult();
+    }
+  }
+  for (const value of (map.externals ?? []) as unknown[]) {
+    const external = requireObject(value, "repository external resource");
+    requireBoundedString(external.id, "external id", 512);
+    requireBoundedString(external.label, "external label", 160);
+    requireBoundedString(external.kind, "external kind", 64);
+    const id = external.id as string;
+    if (!id.startsWith("ext:") || id.length < 5 || paths.has(id)) invalidResult();
+    paths.add(id);
+  }
+  for (const value of map.roads) {
+    const road = requireObject(value, "code road");
+    requireBoundedString(road.source, "road source", 512);
+    requireBoundedString(road.target, "road target", 512);
+    const source = road.source as string;
+    const target = road.target as string;
+    requireBoundedString(road.relation, "road relation", 64);
+    if (!paths.has(source) || !paths.has(target)) invalidResult();
+  }
+}
+
 function parseBackbone(value: unknown): void {
   const backbone = requireObject(value, "project backbone");
   requireBoundedString(backbone.project_id, "project_id", 128);

package/apps/bridge/src/engine/runtime/engine-memory.ts

@@ -7,10 +7,11 @@ import { EngineClient } from "./engine-client";
 import { engineFeatureEnabled, type EngineClientLike } from "./engine-supervisor";
 
 type Options = { env?: NodeJS.ProcessEnv; client?: EngineClientLike };
+type KnowledgeSourceWindow = Pick<MeshSnapshot, "projectId" | "events">;
 let sharedClient: EngineClient | undefined;
 const synced = new Set<string>();
 const pendingSyncs = new Map<string, Promise<void>>();
-const nextIndex = new Map<string, number>();
+const queuedSyncs = new Map<string, { snapshot: KnowledgeSourceWindow; options: Options }>();
 
 function client(options: Options): EngineClientLike {
   return options.client ?? (sharedClient ??= new EngineClient({
@@ -34,23 +35,36 @@ export async function projectKnowledge(
 ): Promise<ProjectKnowledgeRecord[] | undefined> {
   if (!engineFeatureEnabled(options.env ?? process.env)) return undefined;
   try {
-    const result = await client(options).request({
-      operation: "memory.history",
-      input: { project_id: projectId, task_id: taskId,
-        visibility: taskId ? undefined : "project", limit: 32 },
-    }, { timeoutMs: 250 });
-    if (result.operation !== "memory.history" || result.page.project_id !== projectId) return undefined;
-    return result.page.entries.filter((entry) => taskId
-      ? entry.task_id === taskId || entry.visibility === "project"
-      : entry.visibility === "project").map((entry) => ({
-      projectId: entry.project_id, taskId: entry.task_id,
-      recordId: entry.record_id, category: entry.category,
-      content: entry.content, source: entry.source,
-      sourceRef: entry.source_ref, visibility: entry.visibility,
-      repositoryId: entry.repository_id ?? undefined,
-      commitSha: entry.commit_sha ?? undefined,
-      recordedAt: entry.recorded_at, streamVersion: entry.stream_version,
-    }));
+    const records: ProjectKnowledgeRecord[] = [];
+    let beforeVersion: number | undefined;
+    // The local Mesh cache holds at most 256 records. Read that same bounded
+    // window, including corrections, before deciding which entries are active.
+    for (let page = 0; page < 4; page += 1) {
+      const result = await client(options).request({
+        operation: "memory.history",
+        input: { project_id: projectId, task_id: taskId,
+          visibility: taskId ? undefined : "project", limit: 64,
+          include_superseded: true, before_version: beforeVersion },
+      }, { timeoutMs: 250 });
+      if (result.operation !== "memory.history" || result.page.project_id !== projectId) return undefined;
+      records.push(...result.page.entries.filter((entry) => taskId
+        ? entry.task_id === taskId || entry.visibility === "project"
+        : entry.visibility === "project").map((entry) => ({
+        projectId: entry.project_id, taskId: entry.task_id,
+        recordId: entry.record_id, category: entry.category,
+        content: entry.content, source: entry.source,
+        sourceRef: entry.source_ref, visibility: entry.visibility,
+        repositoryId: entry.repository_id ?? undefined,
+        commitSha: entry.commit_sha ?? undefined,
+        supersedesRecordId: entry.supersedes_record_id ?? undefined,
+        recordedAt: entry.recorded_at, streamVersion: entry.stream_version,
+      })));
+      const next = result.page.next_before_version;
+      if (!result.page.incomplete || next == null
+        || beforeVersion != null && next >= beforeVersion) break;
+      beforeVersion = next;
+    }
+    return records;
   } catch { return undefined; }
 }
 
@@ -86,31 +100,39 @@ export function recordsFromEvent(event: MeshEvent): KnowledgeRecordInput[] {
   return [];
 }
 
-/** Backfill the bounded event window once per process, then append only new IDs. */
-export async function syncProjectKnowledge(snapshot: MeshSnapshot, options: Options = {}): Promise<void> {
+/** Backfill retained structured events; a failed Engine write stops this pass. */
+export async function syncProjectKnowledge(snapshot: KnowledgeSourceWindow, options: Options = {}): Promise<void> {
   if (!engineFeatureEnabled(options.env ?? process.env)) return;
   const candidates = snapshot.events.flatMap(recordsFromEvent)
-    .filter((entry) => !synced.has(`${entry.project_id}\0${entry.record_id}`));
+    .filter((entry) => entry.project_id === snapshot.projectId
+      && !synced.has(`${entry.project_id}\0${entry.record_id}`))
+    .slice(-512);
   if (candidates.length === 0) return;
-  const start = (nextIndex.get(snapshot.projectId) ?? 0) % candidates.length;
-  const count = Math.min(candidates.length, 16);
-  nextIndex.set(snapshot.projectId, start + count);
-  for (let offset = 0; offset < count; offset += 1) {
-    const entry = candidates[(start + offset) % candidates.length]!;
-    const key = `${entry.project_id}\0${entry.record_id}`;
-    if (await recordProjectKnowledge(entry, options)) {
-      synced.add(key);
-      if (synced.size > 4_096) synced.delete(synced.values().next().value!);
+  for (const [index, entry] of candidates.entries()) {
+    if (index > 0 && index % 16 === 0) {
+      await new Promise<void>((resolve) => setTimeout(resolve, 0));
     }
+    const key = `${entry.project_id}\0${entry.record_id}`;
+    if (!await recordProjectKnowledge(entry, options)) break;
+    synced.add(key);
+    if (synced.size > 4_096) synced.delete(synced.values().next().value!);
   }
 }
 
 /** Publish never waits for the memory backfill; one bounded writer runs per Project. */
-export function queueProjectKnowledgeSync(snapshot: MeshSnapshot): void {
-  if (pendingSyncs.has(snapshot.projectId)) return;
-  const pending = syncProjectKnowledge(snapshot);
+export function queueProjectKnowledgeSync(snapshot: KnowledgeSourceWindow, options: Options = {}): void {
+  if (pendingSyncs.has(snapshot.projectId)) {
+    queuedSyncs.set(snapshot.projectId, { snapshot, options });
+    return;
+  }
+  const pending = syncProjectKnowledge(snapshot, options);
   pendingSyncs.set(snapshot.projectId, pending);
   void pending.catch(() => undefined).finally(() => {
-    if (pendingSyncs.get(snapshot.projectId) === pending) pendingSyncs.delete(snapshot.projectId);
+    if (pendingSyncs.get(snapshot.projectId) !== pending) return;
+    pendingSyncs.delete(snapshot.projectId);
+    const next = queuedSyncs.get(snapshot.projectId);
+    if (!next) return;
+    queuedSyncs.delete(snapshot.projectId);
+    queueProjectKnowledgeSync(next.snapshot, next.options);
   });
 }

package/apps/bridge/src/engine/runtime/engine-projects.ts

@@ -15,6 +15,7 @@ import type {
   EngineContextEvidence,
 } from "../protocol/engine-protocol";
 import { RepositoryGraphJobs } from "./repository-graph-jobs";
+import { fitRepositoryGraph } from "./repository-graph/fit";
 
 export type LocalProjectBinding = {
   summary: ProjectBindingSummary;
@@ -26,8 +27,8 @@ export type LocalProjectBinding = {
 
 let sharedClient: EngineClient | undefined;
 const pendingBindingSyncs = new Map<string, Promise<boolean>>();
-const MAX_REPOSITORY_GRAPH_WIRE_BYTES = 128 * 1_024;
-const MAX_SINGLE_GRAPH_WIRE_BYTES = 48 * 1_024;
+const MAX_REPOSITORY_GRAPH_WIRE_BYTES = 256 * 1_024;
+const MAX_SINGLE_GRAPH_WIRE_BYTES = 192 * 1_024;
 const repositoryGraphJobs = new RepositoryGraphJobs<ProjectRepositoryGraph>();
 
 export async function syncProjectBinding(
@@ -211,6 +212,20 @@ async function analyzeRepositoryGraph(
       analysisId: graph.analysis_id ?? undefined,
       analysisStatus: graph.analysis_status,
       architectureHypotheses: graph.architecture_hypotheses,
+      codeMap: graph.code_map ? {
+        files: graph.code_map.files.map((file) => ({
+          path: file.path, language: file.language, lineCount: file.line_count,
+          symbols: file.symbols.map((symbol) => ({
+            id: symbol.id, label: symbol.label, kind: symbol.kind,
+            startLine: symbol.start_line, lineCount: symbol.line_count,
+          })),
+        })),
+        externals: graph.code_map.externals ?? [],
+        roads: graph.code_map.roads,
+        totalFiles: graph.code_map.total_files,
+        totalExternals: graph.code_map.total_externals ?? 0,
+        truncated: graph.code_map.truncated,
+      } : undefined,
       nodes: graph.nodes,
       relations: graph.relations.map((edge) => ({
         source: edge.source, target: edge.target, relation: edge.relation,
@@ -249,27 +264,6 @@ function boundRepositoryGraphs(graphs: ProjectRepositoryGraph[]): ProjectReposit
   return result;
 }
 
-function fitRepositoryGraph(
-  graph: ProjectRepositoryGraph,
-  maxBytes: number,
-): ProjectRepositoryGraph | undefined {
-  let nodes = graph.nodes;
-  let relations = graph.relations;
-  let bounded = graph;
-  while (Buffer.byteLength(JSON.stringify(bounded), "utf8") > maxBytes
-    && (nodes.length > 8 || relations.length > 8)) {
-    if (relations.length >= nodes.length && relations.length > 8) {
-      relations = relations.slice(0, Math.max(8, Math.floor(relations.length / 2)));
-    } else if (nodes.length > 8) {
-      nodes = nodes.slice(0, Math.max(8, Math.floor(nodes.length / 2)));
-      const ids = new Set(nodes.map((node) => node.id));
-      relations = relations.filter((edge) => ids.has(edge.source) && ids.has(edge.target));
-    }
-    bounded = { ...graph, nodes, relations, truncated: true };
-  }
-  return Buffer.byteLength(JSON.stringify(bounded), "utf8") <= maxBytes ? bounded : undefined;
-}
-
 function defaultClient(): EngineClient {
   sharedClient ??= new EngineClient({ socketPath: join(configDir(), "engine.sock") });
   return sharedClient;

package/apps/bridge/src/engine/runtime/repository-graph/fit.ts

@@ -0,0 +1,86 @@
+import type { ProjectRepositoryGraph } from "../../../../../../packages/protocol/schema";
+
+type CodeMap = NonNullable<ProjectRepositoryGraph["codeMap"]>;
+type Relation = ProjectRepositoryGraph["relations"][number];
+
+/** Keep a navigable code city and the strongest architecture evidence in the snapshot envelope. */
+export function fitRepositoryGraph(
+  graph: ProjectRepositoryGraph,
+  maxBytes: number,
+): ProjectRepositoryGraph | undefined {
+  let bounded = graph;
+  const bytes = () => Buffer.byteLength(JSON.stringify(bounded), "utf8");
+  if (bytes() <= maxBytes) return bounded;
+  if (bounded.relations.length > 128) {
+    bounded = { ...bounded, relations: strongestRelations(bounded.relations, 128), truncated: true };
+  }
+  while (bytes() > maxBytes) {
+    const map = bounded.codeMap;
+    if (map?.files.some((file) => file.symbols.length > 0)) {
+      bounded = { ...bounded, codeMap: trimSymbols(map) };
+    } else if (bounded.relations.length > 8) {
+      bounded = { ...bounded, relations: strongestRelations(bounded.relations,
+        Math.ceil(bounded.relations.length / 2)), truncated: true };
+    } else if (bounded.nodes.length > 8) {
+      const nodes = bounded.nodes.slice(0, Math.ceil(bounded.nodes.length / 2));
+      const ids = new Set(nodes.map((node) => node.id));
+      bounded = { ...bounded, nodes, relations: bounded.relations.filter((edge) =>
+        ids.has(edge.source) && ids.has(edge.target)), truncated: true };
+    } else if (map && map.roads.length > 16) {
+      bounded = { ...bounded, codeMap: { ...map, truncated: true,
+        roads: map.roads.slice(0, Math.ceil(map.roads.length / 2)) } };
+    } else if (map && map.files.length > 8) {
+      bounded = { ...bounded, codeMap: trimFiles(map) };
+    } else if (map) {
+      bounded = { ...bounded, codeMap: undefined };
+    } else {
+      return undefined;
+    }
+  }
+  return bounded;
+}
+
+function strongestRelations(relations: Relation[], limit: number): Relation[] {
+  return relations.map((edge, index) => ({ edge, index }))
+    .sort((left, right) => (right.edge.evidenceCount ?? 0) - (left.edge.evidenceCount ?? 0)
+      || left.index - right.index)
+    .slice(0, limit).sort((left, right) => left.index - right.index)
+    .map(({ edge }) => edge);
+}
+
+function roadDegree(map: CodeMap): Map<string, number> {
+  const degree = new Map<string, number>();
+  for (const road of map.roads) {
+    degree.set(road.source, (degree.get(road.source) ?? 0) + 1);
+    degree.set(road.target, (degree.get(road.target) ?? 0) + 1);
+  }
+  return degree;
+}
+
+function rankedFiles(map: CodeMap): CodeMap["files"] {
+  const degree = roadDegree(map);
+  return [...map.files].sort((left, right) =>
+    (degree.get(right.path) ?? 0) - (degree.get(left.path) ?? 0)
+      || (right.lineCount ?? 0) - (left.lineCount ?? 0)
+      || left.path.localeCompare(right.path));
+}
+
+function trimSymbols(map: CodeMap): CodeMap {
+  const ranked = rankedFiles(map).filter((file) => file.symbols.length > 0);
+  const keep = new Set(ranked.slice(0, Math.floor(ranked.length / 2)).map((file) => file.path));
+  return { ...map, truncated: true, files: map.files.map((file) => {
+    if (!keep.has(file.path)) return { ...file, symbols: [] };
+    if (ranked.length === 1) return { ...file, symbols: file.symbols.slice(0,
+      Math.floor(file.symbols.length / 2)) };
+    return file;
+  }) };
+}
+
+function trimFiles(map: CodeMap): CodeMap {
+  const files = rankedFiles(map).slice(0, Math.ceil(map.files.length / 2))
+    .sort((left, right) => left.path.localeCompare(right.path));
+  const paths = new Set(files.map((file) => file.path));
+  for (const external of map.externals ?? []) paths.add(external.id);
+  return { ...map, files, truncated: true,
+    roads: map.roads.filter((road) => paths.has(road.source) && paths.has(road.target)) };
+}

package/apps/bridge/src/mesh/catalog/project/observations.ts

@@ -55,6 +55,13 @@ function mcpObservation(
   if (candidates.length === 0) return { state: "not_found" };
   const digests = new Set(candidates.map((server) => server.configDigest).filter(Boolean));
   const artifactDigest = digests.size === 1 ? [...digests][0] : undefined;
+  if (request.artifactDigest) {
+    if (candidates.some((server) => server.configDigest
+      && server.configDigest !== request.artifactDigest)) {
+      return { state: "version_conflict", artifactDigest };
+    }
+    if (candidates.some((server) => !server.configDigest)) return { state: "unsupported" };
+  }
   if (!request.artifactDigest) {
     if (digests.size > 1) return { state: "version_conflict" };
     if (digests.size === 1 && candidates.some((server) => !server.configDigest)) {

package/apps/bridge/src/mesh/context/env.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import type { ProjectEnvironment, ProjectEnvVar } from "../../../../../packages/protocol/schema";
 import { ProjectEnvironment as EnvironmentSchema } from "../../../../../packages/protocol/schema";
@@ -10,6 +10,7 @@ type StoreFile = { environments: ProjectEnvironment[] };
 const PROTECTED_KEYS = new Set([
   "HOME", "PATH", "SHELL", "USER", "LOGNAME", "TMPDIR", "NODE_OPTIONS",
 ]);
+const MANAGED_HEADER = "# GrantTap Project environment. Secrets stay on the Mesh, not here.";
 
 function protectedRuntimeKey(key: string): boolean {
   return PROTECTED_KEYS.has(key)
@@ -76,6 +77,7 @@ export function rememberEnvironment(
 ): ProjectEnvironment | undefined {
   const others = loadAll().filter((item) => item.projectId !== projectId);
   if (!environment) {
+    if (repositoryRoot) removeManagedRepoEnv(repositoryRoot);
     saveAll(others);
     return undefined;
   }
@@ -83,6 +85,8 @@ export function rememberEnvironment(
   const stored = mergeEnvironment({ ...environment, projectId }, loadEnvironment(projectId));
   if (stored.shareNonSecretsWithRepo && repositoryRoot) {
     writeRepoEnv(repositoryRoot, stored.variables);
+  } else if (repositoryRoot) {
+    removeManagedRepoEnv(repositoryRoot);
   }
   saveAll([...others, stored]);
   return stored;
@@ -120,13 +124,39 @@ export function writeRepoEnv(root: string, variables: ProjectEnvVar[]): void {
     .map((item) => `${item.key}=${escapeEnv(item.value ?? "")}`);
   const path = repoEnvPath(root);
   mkdirSync(dirname(path), { recursive: true });
+  if (!lstatSync(dirname(path)).isDirectory()) throw new Error("repository export directory is unsafe");
+  const stat = lstatSync(path, { throwIfNoEntry: false });
+  if (stat) {
+    if (!stat.isFile() || !readFileSync(path, "utf8").startsWith(`${MANAGED_HEADER}\n`)) {
+      throw new Error("repository environment file is not managed by GrantTap");
+    }
+  }
   writeFileSync(
     path,
-    `${["# GrantTap Project environment. Secrets stay on the Mesh, not here.", ...lines].join("\n")}\n`,
+    `${[MANAGED_HEADER, ...lines].join("\n")}\n`,
     { mode: 0o644 },
   );
 }
 
+/** Revoking a share removes a managed export and reports unsafe leftovers. */
+export function removeManagedRepoEnv(root: string): boolean {
+  const path = repoEnvPath(root);
+  try {
+    if (!lstatSync(dirname(path)).isDirectory()) {
+      throw new Error("repository environment directory is unsafe");
+    }
+    if (!lstatSync(path).isFile()
+      || !readFileSync(path, "utf8").startsWith(`${MANAGED_HEADER}\n`)) {
+      throw new Error("repository environment file is not managed by GrantTap");
+    }
+    unlinkSync(path);
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+    throw error;
+  }
+}
+
 function escapeEnv(value: string): string {
   if (!/[\s#"\\]/.test(value)) return value;
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;

package/apps/bridge/src/mesh/context/project.ts

@@ -5,6 +5,9 @@
 import type { ScopedMeshView } from "../snapshot/scoped-view";
 import { compileMeshContext } from "./packet";
 import { projectKnowledge } from "../../engine/runtime/engine-memory";
+import {
+  activeScopedKnowledge, supersededScopedKnowledgeIds, unrecordedKnowledgeEvents,
+} from "../knowledge/active";
 
 export type ProjectContextMode = "compact" | "full" | "legacy";
 
@@ -139,8 +142,16 @@ export async function renderProjectContext(
   const local = await projectKnowledge(view.project.projectId, view.execution.taskId);
   const records = new Map((view.knowledge ?? []).map((item) => [item.recordId, item]));
   for (const item of local ?? []) records.set(item.recordId, item);
-  const scoped = { ...view, knowledge: [...records.values()]
-    .sort((a, b) => b.recordedAt - a.recordedAt).slice(0, 32) };
+  const all = [...records.values()];
+  const supersededKnowledgeRecordIds = [...new Set([
+    ...(view.supersededKnowledgeRecordIds ?? []),
+    ...supersededScopedKnowledgeIds(view.project.projectId, all, view.execution.taskId),
+  ])];
+  const scoped = { ...view,
+    knowledge: activeScopedKnowledge(view.project.projectId, all, view.execution.taskId)
+      .sort((a, b) => b.recordedAt - a.recordedAt).slice(0, 32),
+    supersededKnowledgeRecordIds,
+    events: unrecordedKnowledgeEvents(view.events, all, supersededKnowledgeRecordIds) };
   const contextPacket = await compileMeshContext(scoped);
   if (mode === "compact") return { ...renderCompactProjectContext(scoped), contextPacket };
   if (mode === "legacy") {

package/apps/bridge/src/mesh/knowledge/README.md

@@ -0,0 +1,14 @@
+# Mesh knowledge projection
+
+`active.ts` filters a Project's bounded phone projection using recorded
+supersession links. The Engine journal remains the durable source and retains
+the complete audit history. A correction only hides an earlier record when both
+records have the same Project, visibility, category, and repository scope.
+
+`write.ts` accepts an explicit human decision for an existing Task on a locally
+bound Project, records it through Engine Memory, and returns a `recorded` receipt
+only after the Engine confirms. A correction carries the old record ID; the
+Engine validates its scope. The phone may replay the same ID after a lost reply.
+This is not a migration of old chats into verified knowledge.
+
+MIT License.