@semiont/make-meaning 0.5.9 → 0.5.11

package/dist/index.js

@@ -1,6 +1,6 @@
 import { FsJobQueue } from '@semiont/jobs';
 import { FilesystemViewStorage, resolveStorageUri, EventQuery, createEventStore } from '@semiont/event-sourcing';
-import { getPrimaryRepresentation, decodeRepresentation, getTargetSource, getBodySource, resourceId, getTargetSelector, getResourceEntityTypes, getResourceId, getTextPositionSelector, annotationId, errField, userId, generateUuid, getExactText, cloneToken, baseMediaType, isSupportedMediaType, capabilitiesOf, didToAgent, assembleAnnotation, jobId, entityType, baseUrl, busLog, BRIDGED_CHANNELS, burstBuffer, textExtractionOf, getPrimaryMediaType, extensionForMediaType, applyBodyOperations, findBodyItem } from '@semiont/core';
+import { getPrimaryRepresentation, decodeRepresentation, getResourceEntityTypes, getResourceId, getTargetSource, resourceId, getBodySource, getTargetSelector, deriveViews, getTextPositionSelector, annotationId, errField, userId, generateUuid, getExactText, busRequest, cloneToken, baseMediaType, isSupportedMediaType, capabilitiesOf, didToAgent, assembleAnnotation, jobId, entityType, baseUrl, busLog, BRIDGED_CHANNELS, burstBuffer, textExtractionOf, getPrimaryMediaType, extensionForMediaType, applyBodyOperations, findBodyItem, softwareToAgent } from '@semiont/core';
 import { withActorSpan, recordBusEmit, withSpan, SpanKind, registerJobQueueProvider, registerVectorIndexSizeProvider } from '@semiont/observability';
 import { createInferenceClient } from '@semiont/inference';
 import { getGraphDatabase } from '@semiont/graph';
@@ -9,7 +9,6 @@ import { getEntityTypes, DEFAULT_ENTITY_TYPES } from '@semiont/ontology';
 import { promises } from 'fs';
 import * as path3 from 'path';
 import { chunkText } from '@semiont/vectors';
-import { busRequest } from '@semiont/sdk';
 import { createGzip, createGunzip } from 'zlib';
 import { pipeline, Readable } from 'stream';
 import { promisify } from 'util';
@@ -3569,7 +3568,7 @@ var require_firstValueFrom = __commonJS({
     exports.firstValueFrom = void 0;
     var EmptyError_1 = require_EmptyError();
     var Subscriber_1 = require_Subscriber();
-    function firstValueFrom5(source, config) {
+    function firstValueFrom2(source, config) {
       var hasConfig = typeof config === "object";
       return new Promise(function(resolve2, reject) {
         var subscriber = new Subscriber_1.SafeSubscriber({
@@ -3589,7 +3588,7 @@ var require_firstValueFrom = __commonJS({
         source.subscribe(subscriber);
       });
     }
-    exports.firstValueFrom = firstValueFrom5;
+    exports.firstValueFrom = firstValueFrom2;
   }
 });
 
@@ -3728,7 +3727,7 @@ var require_map = __commonJS({
     exports.map = void 0;
     var lift_1 = require_lift();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
-    function map6(project, thisArg) {
+    function map3(project, thisArg) {
       return lift_1.operate(function(source, subscriber) {
         var index = 0;
         source.subscribe(OperatorSubscriber_1.createOperatorSubscriber(subscriber, function(value) {
@@ -3736,7 +3735,7 @@ var require_map = __commonJS({
         }));
       });
     }
-    exports.map = map6;
+    exports.map = map3;
   }
 });
 
@@ -4566,7 +4565,7 @@ var require_timer = __commonJS({
     var async_1 = require_async();
     var isScheduler_1 = require_isScheduler();
     var isDate_1 = require_isDate();
-    function timer5(dueTime, intervalOrScheduler, scheduler) {
+    function timer2(dueTime, intervalOrScheduler, scheduler) {
       if (dueTime === void 0) {
         dueTime = 0;
       }
@@ -4599,7 +4598,7 @@ var require_timer = __commonJS({
         }, due);
       });
     }
-    exports.timer = timer5;
+    exports.timer = timer2;
   }
 });
 
@@ -4789,7 +4788,7 @@ var require_race = __commonJS({
     var innerFrom_1 = require_innerFrom();
     var argsOrArgArray_1 = require_argsOrArgArray();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
-    function race5() {
+    function race2() {
       var sources = [];
       for (var _i = 0; _i < arguments.length; _i++) {
         sources[_i] = arguments[_i];
@@ -4797,7 +4796,7 @@ var require_race = __commonJS({
       sources = argsOrArgArray_1.argsOrArgArray(sources);
       return sources.length === 1 ? innerFrom_1.innerFrom(sources[0]) : new Observable_1.Observable(raceInit(sources));
     }
-    exports.race = race5;
+    exports.race = race2;
     function raceInit(sources) {
       return function(subscriber) {
         var subscriptions = [];
@@ -5371,13 +5370,13 @@ var require_catchError = __commonJS({
     var innerFrom_1 = require_innerFrom();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
     var lift_1 = require_lift();
-    function catchError(selector) {
+    function catchError2(selector) {
       return lift_1.operate(function(source, subscriber) {
         var innerSub = null;
         var syncUnsub = false;
         var handledResult;
         innerSub = source.subscribe(OperatorSubscriber_1.createOperatorSubscriber(subscriber, void 0, void 0, function(err) {
-          handledResult = innerFrom_1.innerFrom(selector(err, catchError(selector)(source)));
+          handledResult = innerFrom_1.innerFrom(selector(err, catchError2(selector)(source)));
           if (innerSub) {
             innerSub.unsubscribe();
             innerSub = null;
@@ -5393,7 +5392,7 @@ var require_catchError = __commonJS({
         }
       });
     }
-    exports.catchError = catchError;
+    exports.catchError = catchError2;
   }
 });
 
@@ -5888,7 +5887,7 @@ var require_take = __commonJS({
     var empty_1 = require_empty();
     var lift_1 = require_lift();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
-    function take3(count) {
+    function take(count) {
       return count <= 0 ? function() {
         return empty_1.EMPTY;
       } : lift_1.operate(function(source, subscriber) {
@@ -5903,7 +5902,7 @@ var require_take = __commonJS({
         }));
       });
     }
-    exports.take = take3;
+    exports.take = take;
   }
 });
 
@@ -9253,14 +9252,14 @@ var require_race2 = __commonJS({
     exports.race = void 0;
     var argsOrArgArray_1 = require_argsOrArgArray();
     var raceWith_1 = require_raceWith();
-    function race5() {
+    function race2() {
       var args = [];
       for (var _i = 0; _i < arguments.length; _i++) {
         args[_i] = arguments[_i];
       }
       return raceWith_1.raceWith.apply(void 0, __spreadArray([], __read(argsOrArgArray_1.argsOrArgArray(args))));
     }
-    exports.race = race5;
+    exports.race = race2;
   }
 });
 
@@ -9734,10 +9733,19 @@ function resolveActorInference(config, actor) {
     `No inference config found for actor '${actor}'. Set actors.${actor}.inference in your config.`
   );
 }
+function resolveWorkerInference(config, workerType) {
+  const specific = config.workers?.[workerType];
+  if (specific) return specific;
+  const defaultWorker = config.workers?.default;
+  if (defaultWorker) return defaultWorker;
+  throw new Error(
+    `No inference config found for worker '${workerType}'. Set workers.${workerType}.inference or workers.default.inference in your config.`
+  );
+}
 
 // src/service.ts
-var import_rxjs9 = __toESM(require_cjs());
-var import_operators9 = __toESM(require_operators());
+var import_rxjs7 = __toESM(require_cjs());
+var import_operators7 = __toESM(require_operators());
 
 // src/graph/consumer.ts
 var import_rxjs = __toESM(require_cjs());
@@ -10056,7 +10064,7 @@ var GraphDBConsumer = class _GraphDBConsumer {
         {
           const rid = resourceId(event.resourceId);
           const doc = await graphDb.getResource(rid);
-          if (doc) {
+          if (doc && !(doc.entityTypes || []).includes(event.payload.entityType)) {
             await graphDb.updateResource(rid, {
               entityTypes: [...doc.entityTypes || [], event.payload.entityType]
             });
@@ -10293,6 +10301,93 @@ var ResourceContext = class _ResourceContext {
     return void 0;
   }
 };
+var GraphContext = class {
+  /**
+   * Get all resources referencing this resource (backlinks)
+   * Requires graph traversal - must use graph database
+   */
+  static async getBacklinks(resourceId10, kb) {
+    return kb.graph.getResourceReferencedBy(resourceId10);
+  }
+  /**
+   * Find shortest path between two resources
+   * Requires graph traversal - must use graph database
+   */
+  static async findPath(fromResourceId, toResourceId, kb, maxDepth) {
+    return kb.graph.findPath(fromResourceId, toResourceId, maxDepth);
+  }
+  /**
+   * Get resource connections (graph edges)
+   * Requires graph traversal - must use graph database
+   */
+  static async getResourceConnections(resourceId10, kb) {
+    return kb.graph.getResourceConnections(resourceId10);
+  }
+  /**
+   * Search resources by name (cross-resource query)
+   * Requires full-text search - must use graph database
+   */
+  static async searchResources(query, kb, limit) {
+    return kb.graph.searchResources(query, limit);
+  }
+  /**
+   * Build the unified knowledge graph for a resource's neighborhood:
+   * resources AND annotations as typed nodes, typed/directional edges.
+   *
+   * This is the single graph builder (CONTEXT-UNIFICATION D3) — both the
+   * matcher (ranking) and the resource/viz path consume it. The flattened
+   * signals the matcher reads today (`connections`, `citedBy`/count,
+   * `siblingEntityTypes`, `bidirectional`) are all derivable from this:
+   *  - peer connections → resource nodes + main→peer edges carrying `bidirectional`
+   *  - inbound citations → citing-resource nodes + `citation` edges (citing→main),
+   *    so citedByCount = inbound citation-edge count
+   *  - annotations on the resource → `annotation` nodes + `annotation-of` edges,
+   *    so siblingEntityTypes = union of those nodes' entityTypes
+   */
+  static async buildKnowledgeGraph(resourceId10, kb) {
+    const mainDoc = await kb.graph.getResource(resourceId10);
+    if (!mainDoc) {
+      throw new Error("Resource not found");
+    }
+    const mainId = String(resourceId10);
+    const [connections, referencedBy, annotations] = await Promise.all([
+      kb.graph.getResourceConnections(resourceId10),
+      kb.graph.getResourceReferencedBy(resourceId10),
+      kb.graph.getResourceAnnotations(resourceId10)
+    ]);
+    const nodes = [];
+    const edges = [];
+    const seen = /* @__PURE__ */ new Set();
+    const addResourceNode = (id, label, entityTypes) => {
+      if (!id || seen.has(id)) return;
+      nodes.push({ id, type: "resource", label, entityTypes });
+      seen.add(id);
+    };
+    addResourceNode(mainId, mainDoc.name, getResourceEntityTypes(mainDoc));
+    for (const conn of connections) {
+      const peerId = getResourceId(conn.targetResource);
+      if (!peerId) continue;
+      addResourceNode(peerId, conn.targetResource.name, getResourceEntityTypes(conn.targetResource));
+      edges.push({ source: mainId, target: peerId, type: conn.relationshipType || "link", bidirectional: conn.bidirectional });
+    }
+    const citedSeen = /* @__PURE__ */ new Set();
+    for (const ann of referencedBy) {
+      const source = getTargetSource(ann.target);
+      if (!source || source === String(resourceId10) || citedSeen.has(source)) continue;
+      citedSeen.add(source);
+      const view = await kb.views.get(resourceId(source));
+      addResourceNode(source, view?.resource?.name ?? source, view?.resource ? getResourceEntityTypes(view.resource) : []);
+      edges.push({ source, target: mainId, type: "citation" });
+    }
+    for (const ann of annotations) {
+      if (!ann.id || seen.has(ann.id)) continue;
+      nodes.push({ id: ann.id, type: "annotation", label: ann.motivation ?? "annotation", entityTypes: getEntityTypes(ann) });
+      seen.add(ann.id);
+      edges.push({ source: ann.id, target: mainId, type: "annotation-of" });
+    }
+    return { nodes, edges };
+  }
+};
 
 // src/annotation-context.ts
 var AnnotationContext = class {
@@ -10406,42 +10501,21 @@ var AnnotationContext = class {
         };
       }
     }
-    logger?.debug("Building graph context", { resourceId: resourceId10 });
-    const [connections, referencedByAnnotations, entityTypeStats] = await Promise.all([
-      kb.graph.getResourceConnections(resourceId10),
-      kb.graph.getResourceReferencedBy(resourceId10),
-      kb.graph.getEntityTypeStats()
-    ]);
-    const citedByMap = /* @__PURE__ */ new Map();
-    for (const ann of referencedByAnnotations) {
-      const source = getTargetSource(ann.target);
-      if (source && source !== String(resourceId10)) {
-        const sourceResId = resourceId(source);
-        const sourceView2 = await kb.views.get(sourceResId);
-        if (sourceView2?.resource) {
-          citedByMap.set(source, sourceView2.resource.name);
-        }
-      }
-    }
-    const annotationEntityTypes = getEntityTypes(annotation);
-    const siblingEntityTypes = /* @__PURE__ */ new Set();
-    for (const ann of sourceView.annotations.annotations) {
-      if (ann.id !== annotationId5) {
-        for (const et of getEntityTypes(ann)) {
-          siblingEntityTypes.add(et);
-        }
-      }
-    }
+    logger?.debug("Building knowledge graph", { resourceId: resourceId10 });
+    const graph = await GraphContext.buildKnowledgeGraph(resourceId10, kb);
+    const views = deriveViews(graph, String(resourceId10), annotationId5);
+    const entityTypeStats = await kb.graph.getEntityTypeStats();
     const entityTypeFrequencies = {};
     for (const stat of entityTypeStats) {
       entityTypeFrequencies[stat.type] = stat.count;
     }
+    const annotationEntityTypes = getEntityTypes(annotation);
     let inferredRelationshipSummary;
     if (inferenceClient && sourceContext) {
       try {
-        const connNames = connections.map((c) => c.targetResource.name).slice(0, 10);
-        const citedByNames = Array.from(citedByMap.values()).slice(0, 5);
-        const siblingTypes = Array.from(siblingEntityTypes).slice(0, 10);
+        const connNames = views.connections.map((c) => c.resourceName).slice(0, 10);
+        const citedByNames = views.citedBy.map((c) => c.resourceName).slice(0, 5);
+        const siblingTypes = views.siblingEntityTypes.slice(0, 10);
         const parts = [];
         parts.push(`Passage: "${sourceContext.selected}"`);
         if (connNames.length > 0) parts.push(`Connected resources: ${connNames.join(", ")}`);
@@ -10459,27 +10533,6 @@ Summary:`;
         logger?.warn("Failed to generate inferred relationship summary", { error });
       }
     }
-    const graphContext = {
-      connections: connections.map((conn) => ({
-        resourceId: getResourceId(conn.targetResource) ?? "",
-        resourceName: conn.targetResource.name,
-        entityTypes: getResourceEntityTypes(conn.targetResource),
-        bidirectional: conn.bidirectional
-      })),
-      citedByCount: citedByMap.size,
-      citedBy: Array.from(citedByMap.entries()).map(([id, name]) => ({
-        resourceId: id,
-        resourceName: name
-      })),
-      siblingEntityTypes: Array.from(siblingEntityTypes),
-      entityTypeFrequencies,
-      ...inferredRelationshipSummary ? { inferredRelationshipSummary } : {}
-    };
-    logger?.debug("Built graph context", {
-      connections: connections.length,
-      citedByCount: citedByMap.size,
-      siblingEntityTypes: siblingEntityTypes.size
-    });
     let semanticContext;
     if (kb.vectors && embeddingProvider && sourceContext?.selected) {
       try {
@@ -10505,32 +10558,26 @@ Summary:`;
         logger?.warn("Semantic context search failed", { error });
       }
     }
-    const generationContext = {
-      annotation,
-      sourceResource: sourceDoc,
+    const context = {
+      focus: {
+        kind: "annotation",
+        annotation,
+        sourceResource: sourceDoc,
+        ...sourceContext ? { selected: { before: sourceContext.before || "", text: sourceContext.selected, after: sourceContext.after || "" } } : {},
+        ...targetDoc ? { targetResource: targetDoc } : {},
+        ...targetContext ? { targetContext } : {}
+      },
+      graph,
       metadata: {
         resourceType: "document",
         language: sourceDoc.language,
-        entityTypes: annotationEntityTypes
+        entityTypes: annotationEntityTypes,
+        entityTypeFrequencies
       },
-      graphContext,
+      ...inferredRelationshipSummary ? { inferredRelationshipSummary } : {},
       ...semanticContext ? { semanticContext } : {}
     };
-    if (sourceContext) {
-      generationContext.sourceContext = {
-        before: sourceContext.before || "",
-        selected: sourceContext.selected,
-        after: sourceContext.after || ""
-      };
-    }
-    const response = {
-      annotation,
-      sourceResource: sourceDoc,
-      targetResource: targetDoc,
-      context: generationContext,
-      ...targetContext ? { targetContext } : {}
-    };
-    return response;
+    return context;
   }
   /**
    * Get resource annotations from view storage (fast path)
@@ -10764,69 +10811,6 @@ Entity types: ${entityTypes.join(", ")}`;
     return inferenceClient.generateText(summaryPrompt, 500, 0.5);
   }
 };
-var GraphContext = class {
-  /**
-   * Get all resources referencing this resource (backlinks)
-   * Requires graph traversal - must use graph database
-   */
-  static async getBacklinks(resourceId10, kb) {
-    return kb.graph.getResourceReferencedBy(resourceId10);
-  }
-  /**
-   * Find shortest path between two resources
-   * Requires graph traversal - must use graph database
-   */
-  static async findPath(fromResourceId, toResourceId, kb, maxDepth) {
-    return kb.graph.findPath(fromResourceId, toResourceId, maxDepth);
-  }
-  /**
-   * Get resource connections (graph edges)
-   * Requires graph traversal - must use graph database
-   */
-  static async getResourceConnections(resourceId10, kb) {
-    return kb.graph.getResourceConnections(resourceId10);
-  }
-  /**
-   * Search resources by name (cross-resource query)
-   * Requires full-text search - must use graph database
-   */
-  static async searchResources(query, kb, limit) {
-    return kb.graph.searchResources(query, limit);
-  }
-  /**
-   * Build graph representation with nodes and edges for a resource and its connections
-   * Retrieves connections from graph and builds visualization-ready structure
-   */
-  static async buildGraphRepresentation(resourceId10, maxRelated, kb) {
-    const mainDoc = await kb.graph.getResource(resourceId10);
-    if (!mainDoc) {
-      throw new Error("Resource not found");
-    }
-    const connections = await kb.graph.getResourceConnections(resourceId10);
-    const relatedDocs = connections.map((conn) => conn.targetResource).slice(0, maxRelated - 1);
-    const nodes = [
-      {
-        id: getResourceId(mainDoc),
-        type: "resource",
-        label: mainDoc.name,
-        metadata: { entityTypes: getResourceEntityTypes(mainDoc) }
-      },
-      ...relatedDocs.map((doc) => ({
-        id: getResourceId(doc),
-        type: "resource",
-        label: doc.name,
-        metadata: { entityTypes: getResourceEntityTypes(doc) }
-      }))
-    ].filter((node) => node.id !== void 0);
-    const edges = connections.slice(0, maxRelated - 1).map((conn) => ({
-      source: resourceId10,
-      target: getResourceId(conn.targetResource),
-      type: conn.relationshipType || "link",
-      metadata: {}
-    })).filter((edge) => edge.target !== void 0);
-    return { nodes, edges };
-  }
-};
 var LLMContext = class {
   /**
    * Get comprehensive LLM context for a resource
@@ -10838,35 +10822,29 @@ var LLMContext = class {
       throw new Error("Resource not found");
     }
     const mainContent = options.includeContent ? await ResourceContext.getResourceContent(mainDoc, kb) : void 0;
-    const graph = await GraphContext.buildGraphRepresentation(
-      resourceId10,
-      options.maxResources,
-      kb
-    );
-    const relatedDocs = [];
+    const graph = await GraphContext.buildKnowledgeGraph(resourceId10, kb);
     const resourceIdStr = resourceId10.toString();
-    for (const node of graph.nodes) {
-      if (node.id !== resourceIdStr) {
-        const relatedDoc = await ResourceContext.getResourceMetadata(resourceId(node.id), kb);
-        if (relatedDoc) {
-          relatedDocs.push(relatedDoc);
-        }
+    const relatedDocs = [];
+    const relatedNodes = graph.nodes.filter((node) => node.type === "resource" && node.id !== resourceIdStr).slice(0, Math.max(0, options.maxResources - 1));
+    for (const node of relatedNodes) {
+      const relatedDoc = await ResourceContext.getResourceMetadata(resourceId(node.id), kb);
+      if (relatedDoc) {
+        relatedDocs.push(relatedDoc);
       }
     }
-    const relatedResourcesContent = {};
+    const relatedContent = {};
     if (options.includeContent) {
       await Promise.all(
         relatedDocs.map(async (doc) => {
           const docId = getResourceId(doc);
           if (!docId) return;
-          const content = await ResourceContext.getResourceContent(doc, kb);
-          if (content) {
-            relatedResourcesContent[docId] = content;
+          const content2 = await ResourceContext.getResourceContent(doc, kb);
+          if (content2) {
+            relatedContent[docId] = content2;
           }
         })
       );
     }
-    const annotations = await AnnotationContext.getAllAnnotations(resourceId10, kb);
     const summary = options.includeSummary && mainContent ? await generateResourceSummary(
       mainDoc.name,
       mainContent,
@@ -10874,15 +10852,44 @@ var LLMContext = class {
       inferenceClient
     ) : void 0;
     const suggestedReferences = mainContent ? await generateReferenceSuggestions(mainContent, inferenceClient) : void 0;
+    const content = {};
+    if (mainContent) content.main = mainContent;
+    if (options.includeContent) content.related = relatedContent;
+    let semanticContext;
+    if (kb.vectors) {
+      const excludeEntityTypes = options.excludeEntityTypes ?? [];
+      const matches = await kb.vectors.searchByResource(resourceId10, {
+        limit: options.maxResources,
+        scoreThreshold: 0.5,
+        ...excludeEntityTypes.length ? { filter: { excludeEntityTypes } } : {}
+      });
+      if (matches.length > 0) {
+        semanticContext = {
+          similar: matches.map((m) => ({
+            text: m.text,
+            resourceId: m.resourceId,
+            ...m.annotationId ? { annotationId: m.annotationId } : {},
+            score: m.score,
+            ...m.entityTypes ? { entityTypes: m.entityTypes } : {}
+          })),
+          ...excludeEntityTypes.length ? { excludedEntityTypes: excludeEntityTypes } : {}
+        };
+      }
+    }
     return {
-      mainResource: mainDoc,
-      relatedResources: relatedDocs,
-      annotations,
+      focus: {
+        kind: "resource",
+        resource: mainDoc,
+        ...summary ? { summary } : {},
+        ...suggestedReferences ? { suggestedReferences } : {},
+        ...Object.keys(content).length > 0 ? { content } : {}
+      },
       graph,
-      ...mainContent ? { mainResourceContent: mainContent } : {},
-      ...options.includeContent ? { relatedResourcesContent } : {},
-      ...summary ? { summary } : {},
-      ...suggestedReferences ? { suggestedReferences } : {}
+      ...semanticContext ? { semanticContext } : {},
+      metadata: {
+        resourceType: "document",
+        language: mainDoc.language
+      }
     };
   }
 };
@@ -11042,8 +11049,13 @@ var Matcher = class {
   async handleSearch(event) {
     try {
       const context = event.context;
-      const selectedText = context.sourceContext?.selected ?? "";
-      const userHint = context.userHint ?? "";
+      if (context.focus.kind !== "annotation") {
+        throw new Error(`Matcher expected annotation focus, received '${context.focus.kind}'`);
+      }
+      const focus = context.focus;
+      const mainResourceId = String(event.resourceId);
+      const selectedText = focus.selected?.text ?? "";
+      const userHint = focus.userHint ?? "";
       const searchTerm = [selectedText, userHint].filter(Boolean).join(" ");
       this.logger.debug("Searching for binding candidates", {
         referenceId: event.referenceId,
@@ -11054,6 +11066,8 @@ var Matcher = class {
       const scored = await this.contextDrivenSearch(
         searchTerm,
         context,
+        focus,
+        mainResourceId,
         event.useSemanticScoring
       );
       const limited = event.limit ? scored.slice(0, event.limit) : scored;
@@ -11089,9 +11103,10 @@ var Matcher = class {
    * - Name match quality (exact > prefix > contains)
    * - Recency (newer resources scored higher)
    */
-  async contextDrivenSearch(searchTerm, context, useSemanticScoring) {
-    const annotationEntityTypes = context.metadata?.entityTypes ?? [];
-    const connections = context.graphContext?.connections ?? [];
+  async contextDrivenSearch(searchTerm, context, focus, mainResourceId, useSemanticScoring) {
+    const annotationEntityTypes = context.metadata.entityTypes ?? [];
+    const views = deriveViews(context.graph, mainResourceId);
+    const connections = views.connections;
     const [nameMatches, entityTypeMatches, semanticMatches] = await Promise.all([
       this.kb.graph.searchResources(searchTerm),
       annotationEntityTypes.length > 0 ? this.kb.graph.listResources({ entityTypes: annotationEntityTypes, limit: 50 }).then((r) => r.resources) : Promise.resolve([]),
@@ -11136,7 +11151,7 @@ var Matcher = class {
     const bidirectionalIds = new Set(
       connections.filter((c) => c.bidirectional).map((c) => c.resourceId)
     );
-    const entityTypeFreqs = context.graphContext?.entityTypeFrequencies ?? {};
+    const entityTypeFreqs = context.metadata.entityTypeFrequencies ?? {};
     const searchTermLower = searchTerm.toLowerCase();
     const scored = Array.from(candidateMap.values()).map(({ resource, sources }) => {
       const id = getResourceId(resource) ?? "";
@@ -11165,7 +11180,7 @@ var Matcher = class {
         score += 10;
         reasons.push("connected");
       }
-      const citedByCount = context.graphContext?.citedByCount ?? 0;
+      const citedByCount = views.citedByCount;
       if (sources.has("neighborhood") && citedByCount > 0) {
         score += Math.min(citedByCount * 2, 15);
       }
@@ -11206,6 +11221,8 @@ var Matcher = class {
         const inferenceScores = await this.inferenceSemanticScore(
           searchTerm,
           context,
+          focus,
+          connections,
           scored.slice(0, 20)
           // Limit to top 20 candidates for cost
         );
@@ -11240,20 +11257,18 @@ var Matcher = class {
    *
    * @returns Map of resourceId → score (0-1)
    */
-  async inferenceSemanticScore(searchTerm, context, candidates) {
-    const passage = [context.sourceContext?.selected, context.userHint].filter(Boolean).join(" \u2014 ") || searchTerm;
-    const entityTypes = context.metadata?.entityTypes ?? [];
-    const graphConnections = context.graphContext?.connections;
-    const connections = graphConnections ?? [];
+  async inferenceSemanticScore(searchTerm, context, focus, connections, candidates) {
+    const passage = [focus.selected?.text, focus.userHint].filter(Boolean).join(" \u2014 ") || searchTerm;
+    const entityTypes = context.metadata.entityTypes ?? [];
     const candidateLines = candidates.map((c, i) => {
       const id = getResourceId(c) ?? "";
       const cEntityTypes = getResourceEntityTypes(c);
       return `${i + 1}. "${c.name}" (id: ${id}, types: ${cEntityTypes.join(", ") || "none"})`;
     }).join("\n");
     const contextParts = [];
-    contextParts.push(`Annotation motivation: ${context.annotation.motivation}`);
-    contextParts.push(`Source resource: ${context.sourceResource.name}`);
-    const { motivation, body } = context.annotation;
+    contextParts.push(`Annotation motivation: ${focus.annotation.motivation}`);
+    contextParts.push(`Source resource: ${focus.sourceResource.name}`);
+    const { motivation, body } = focus.annotation;
     if (motivation === "commenting" || motivation === "assessing") {
       const bodyItem = Array.isArray(body) ? body[0] : body;
       if (bodyItem && "value" in bodyItem && bodyItem.value) {
@@ -11266,8 +11281,8 @@ var Matcher = class {
       const connNames = connections.slice(0, 5).map((c) => c.resourceName);
       contextParts.push(`Connected resources: ${connNames.join(", ")}`);
     }
-    if (context.graphContext?.inferredRelationshipSummary) {
-      contextParts.push(`Relationship context: ${context.graphContext.inferredRelationshipSummary}`);
+    if (context.inferredRelationshipSummary) {
+      contextParts.push(`Relationship context: ${context.inferredRelationshipSummary}`);
     }
     const prompt = `Given this passage and context, score each candidate resource's semantic relevance on a scale of 0.0 to 1.0.
 
@@ -11339,14 +11354,59 @@ For each candidate, output a line with the number and score, like:
 // src/stower.ts
 var import_rxjs4 = __toESM(require_cjs());
 var import_operators4 = __toESM(require_operators());
+async function readEntityTypesProjection(project) {
+  const entityTypesPath = path3.join(
+    project.stateDir,
+    "projections",
+    "__system__",
+    "entitytypes.json"
+  );
+  try {
+    const content = await promises.readFile(entityTypesPath, "utf-8");
+    const projection = JSON.parse(content);
+    return projection.entityTypes || [];
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+
+// src/views/projection-validators.ts
+function resolveTagSchema(tagSchemas, schemaId) {
+  if (typeof schemaId !== "string" || !schemaId) {
+    return { error: "tag-annotation requires schemaId" };
+  }
+  const schema = tagSchemas.find((s) => s.id === schemaId);
+  if (!schema) {
+    return { error: `Tag schema not registered: ${schemaId}` };
+  }
+  return { schema };
+}
+function validateEntityTypes(registered, requested) {
+  if (!requested || requested.length === 0) {
+    return { ok: true };
+  }
+  const set = new Set(registered);
+  const unknown = requested.filter((t) => !set.has(t));
+  return unknown.length > 0 ? { ok: false, unknown } : { ok: true };
+}
+function entityTypesNotRegisteredMessage(unknown) {
+  return `Entity type not registered: ${unknown.join(", ")}`;
+}
+
+// src/stower.ts
 var Stower = class {
-  constructor(kb, eventBus, logger) {
+  constructor(kb, eventBus, project, logger) {
     this.kb = kb;
     this.eventBus = eventBus;
+    this.project = project;
     this.logger = logger;
   }
   kb;
   eventBus;
+  project;
   subscription = null;
   logger;
   async initialize() {
@@ -11411,26 +11471,10 @@ var Stower = class {
           generator: event.generator
         }
       });
-      const resource = {
-        "@context": "https://schema.org/",
-        "@id": rId,
-        name: event.name,
-        archived: false,
-        entityTypes: event.entityTypes || [],
-        storageUri: event.storageUri,
-        currentChecksum: checksum,
-        dateCreated: (/* @__PURE__ */ new Date()).toISOString(),
-        representations: [
-          {
-            mediaType: event.format,
-            checksum,
-            byteSize,
-            rel: "original",
-            language: event.language
-          }
-        ]
-      };
-      this.eventBus.get("yield:create-ok").next({ resourceId: rId, resource });
+      this.eventBus.get("yield:create-ok").next({
+        correlationId: event.correlationId,
+        response: { resourceId: rId }
+      });
       if (generatedFrom) {
         this.eventBus.get("mark:update-body").next({
           annotationId: generatedFrom.annotationId,
@@ -11456,6 +11500,7 @@ var Stower = class {
     } catch (error) {
       this.logger.error("Failed to create resource", { error: errField(error) });
       this.eventBus.get("yield:create-failed").next({
+        correlationId: event.correlationId,
         message: error instanceof Error ? error.message : String(error)
       });
     }
@@ -11476,11 +11521,14 @@ var Stower = class {
           contentByteSize: event.byteSize
         }
       });
-      this.eventBus.get("yield:update-ok").next({ resourceId: event.resourceId });
+      this.eventBus.get("yield:update-ok").next({
+        correlationId: event.correlationId,
+        response: { resourceId: event.resourceId }
+      });
     } catch (error) {
       this.logger.error("Failed to update resource", { error: errField(error) });
       this.eventBus.get("yield:update-failed").next({
-        resourceId: event.resourceId,
+        correlationId: event.correlationId,
         message: error instanceof Error ? error.message : String(error)
       });
     }
@@ -11513,7 +11561,6 @@ var Stower = class {
           toUri: event.toUri
         }
       });
-      this.eventBus.get("yield:move-ok").next({ resourceId: rId });
     } catch (error) {
       this.logger.error("Failed to move resource", { error: errField(error) });
       this.eventBus.get("yield:move-failed").next({
@@ -11561,10 +11608,11 @@ var Stower = class {
         version: 1,
         payload: { annotationId: annotationId(event.annotationId) }
       });
-      this.eventBus.get("mark:delete-ok").next({ annotationId: event.annotationId });
+      this.eventBus.get("mark:delete-ok").next({ correlationId: event.correlationId, response: { annotationId: event.annotationId } });
     } catch (error) {
       this.logger.error("Failed to delete annotation", { error: errField(error) });
       this.eventBus.get("mark:delete-failed").next({
+        correlationId: event.correlationId,
         message: error instanceof Error ? error.message : String(error)
       });
     }
@@ -11598,37 +11646,54 @@ var Stower = class {
     if (!event._userId) {
       throw new Error("mark:archive missing _userId (gateway injection)");
     }
-    if (event.storageUri) {
-      await this.kb.content.remove(event.storageUri, { keepFile: event.keepFile, noGit: event.noGit });
+    try {
+      if (event.storageUri) {
+        await this.kb.content.remove(event.storageUri, { keepFile: event.keepFile, noGit: event.noGit });
+      }
+      await this.kb.eventStore.appendEvent({
+        type: "mark:archived",
+        resourceId: resourceId(event.resourceId),
+        userId: userId(event._userId),
+        version: 1,
+        payload: { reason: void 0 }
+      });
+      this.eventBus.get("mark:archive-ok").next({ correlationId: event.correlationId });
+    } catch (error) {
+      this.logger.error("Failed to archive resource", { error: errField(error) });
+      this.eventBus.get("mark:archive-failed").next({
+        correlationId: event.correlationId,
+        message: error instanceof Error ? error.message : String(error)
+      });
     }
-    await this.kb.eventStore.appendEvent({
-      type: "mark:archived",
-      resourceId: resourceId(event.resourceId),
-      userId: userId(event._userId),
-      version: 1,
-      payload: { reason: void 0 }
-    });
   }
   async handleMarkUnarchive(event) {
     if (!event._userId) {
       throw new Error("mark:unarchive missing _userId (gateway injection)");
     }
-    if (event.storageUri) {
-      const absPath = this.kb.content.resolveUri(event.storageUri);
-      try {
-        await promises.access(absPath);
-      } catch {
-        this.logger.warn("Unarchive failed: file not found at storageUri", { storageUri: event.storageUri });
-        return;
+    try {
+      if (event.storageUri) {
+        const absPath = this.kb.content.resolveUri(event.storageUri);
+        try {
+          await promises.access(absPath);
+        } catch {
+          throw new Error(`Cannot unarchive: file not found at ${event.storageUri}`);
+        }
       }
+      await this.kb.eventStore.appendEvent({
+        type: "mark:unarchived",
+        resourceId: resourceId(event.resourceId),
+        userId: userId(event._userId),
+        version: 1,
+        payload: {}
+      });
+      this.eventBus.get("mark:unarchive-ok").next({ correlationId: event.correlationId });
+    } catch (error) {
+      this.logger.error("Failed to unarchive resource", { error: errField(error) });
+      this.eventBus.get("mark:unarchive-failed").next({
+        correlationId: event.correlationId,
+        message: error instanceof Error ? error.message : String(error)
+      });
     }
-    await this.kb.eventStore.appendEvent({
-      type: "mark:unarchived",
-      resourceId: resourceId(event.resourceId),
-      userId: userId(event._userId),
-      version: 1,
-      payload: {}
-    });
   }
   async handleAddEntityType(event) {
     if (!event._userId) {
@@ -11641,9 +11706,11 @@ var Stower = class {
         version: 1,
         payload: { entityType: event.tag }
       });
+      this.eventBus.get("frame:entity-type-add-ok").next({ correlationId: event.correlationId });
     } catch (error) {
       this.logger.error("Failed to add entity type", { error: errField(error) });
       this.eventBus.get("frame:entity-type-add-failed").next({
+        correlationId: event.correlationId,
         message: error instanceof Error ? error.message : String(error)
       });
     }
@@ -11659,9 +11726,11 @@ var Stower = class {
         version: 1,
         payload: { schema: event.schema }
       });
+      this.eventBus.get("frame:tag-schema-add-ok").next({ correlationId: event.correlationId });
     } catch (error) {
       this.logger.error("Failed to add tag schema", { schemaId: event.schema?.id, error: errField(error) });
       this.eventBus.get("frame:tag-schema-add-failed").next({
+        correlationId: event.correlationId,
         message: error instanceof Error ? error.message : String(error)
       });
     }
@@ -11673,22 +11742,38 @@ var Stower = class {
     const uid = userId(event._userId);
     const added = event.updatedEntityTypes.filter((et) => !event.currentEntityTypes.includes(et));
     const removed = event.currentEntityTypes.filter((et) => !event.updatedEntityTypes.includes(et));
-    for (const entityType2 of added) {
-      await this.kb.eventStore.appendEvent({
-        type: "mark:entity-tag-added",
-        resourceId: resourceId(event.resourceId),
-        userId: uid,
-        version: 1,
-        payload: { entityType: entityType2 }
-      });
-    }
-    for (const entityType2 of removed) {
-      await this.kb.eventStore.appendEvent({
-        type: "mark:entity-tag-removed",
-        resourceId: resourceId(event.resourceId),
-        userId: uid,
-        version: 1,
-        payload: { entityType: entityType2 }
+    try {
+      if (added.length > 0) {
+        const registered = await readEntityTypesProjection(this.project);
+        const result = validateEntityTypes(registered, added);
+        if (!result.ok) {
+          throw new Error(entityTypesNotRegisteredMessage(result.unknown));
+        }
+      }
+      for (const entityType2 of added) {
+        await this.kb.eventStore.appendEvent({
+          type: "mark:entity-tag-added",
+          resourceId: resourceId(event.resourceId),
+          userId: uid,
+          version: 1,
+          payload: { entityType: entityType2 }
+        });
+      }
+      for (const entityType2 of removed) {
+        await this.kb.eventStore.appendEvent({
+          type: "mark:entity-tag-removed",
+          resourceId: resourceId(event.resourceId),
+          userId: uid,
+          version: 1,
+          payload: { entityType: entityType2 }
+        });
+      }
+      this.eventBus.get("mark:update-entity-types-ok").next({ correlationId: event.correlationId });
+    } catch (error) {
+      this.logger.error("Failed to update entity types", { error: errField(error) });
+      this.eventBus.get("mark:update-entity-types-failed").next({
+        correlationId: event.correlationId,
+        message: error instanceof Error ? error.message : String(error)
       });
     }
   }
@@ -11752,24 +11837,6 @@ var Stower = class {
 // src/browser.ts
 var import_rxjs5 = __toESM(require_cjs());
 var import_operators5 = __toESM(require_operators());
-async function readEntityTypesProjection(project) {
-  const entityTypesPath = path3.join(
-    project.stateDir,
-    "projections",
-    "__system__",
-    "entitytypes.json"
-  );
-  try {
-    const content = await promises.readFile(entityTypesPath, "utf-8");
-    const projection = JSON.parse(content);
-    return projection.entityTypes || [];
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return [];
-    }
-    throw error;
-  }
-}
 async function readTagSchemasProjection(project) {
   const tagSchemasPath = path3.join(
     project.stateDir,
@@ -11800,20 +11867,66 @@ async function assembleResourceGraph(kb, resourceId10) {
   });
   return { resource: stored.resource, annotations, entityReferences };
 }
+var JOB_TYPES = [
+  "reference-annotation",
+  "highlight-annotation",
+  "assessment-annotation",
+  "comment-annotation",
+  "tag-annotation",
+  "generation"
+];
+function deriveAgentRoster(config) {
+  const domain = config.site?.domain;
+  if (!domain) {
+    throw new Error(
+      "site.domain is required to mint agent DIDs \u2014 the directory must use the same canonical domain /api/tokens/agent mints worker DIDs from (no topology fallback)"
+    );
+  }
+  const roster = /* @__PURE__ */ new Map();
+  const admit = (inference, jobType) => {
+    const key = `${inference.type}\0${inference.model}`;
+    let entry = roster.get(key);
+    if (!entry) {
+      entry = {
+        agent: softwareToAgent({ domain, provider: inference.type, model: inference.model }),
+        servesJobTypes: []
+      };
+      roster.set(key, entry);
+    }
+    if (jobType) entry.servesJobTypes.push(jobType);
+  };
+  for (const jobType of JOB_TYPES) {
+    try {
+      admit(resolveWorkerInference(config, jobType), jobType);
+    } catch {
+    }
+  }
+  for (const actor of ["gatherer", "matcher"]) {
+    try {
+      admit(resolveActorInference(config, actor));
+    } catch {
+    }
+  }
+  return [...roster.values()].map(
+    ({ agent, servesJobTypes }) => servesJobTypes.length ? { agent, servesJobTypes } : { agent }
+  );
+}
 
 // src/browser.ts
 var Browser = class {
-  constructor(views, kb, eventBus, project, logger) {
+  constructor(views, kb, eventBus, project, config, logger) {
     this.views = views;
     this.kb = kb;
     this.eventBus = eventBus;
     this.project = project;
+    this.config = config;
     this.logger = logger;
   }
   views;
   kb;
   eventBus;
   project;
+  config;
   subscriptions = [];
   logger;
   async initialize() {
@@ -11821,7 +11934,19 @@ var Browser = class {
     const errorHandler = (err) => this.logger.error("Browser pipeline error", { error: err });
     const pipe = (name, handler) => this.eventBus.get(name).pipe(
       (0, import_operators5.mergeMap)(
-        (event) => (0, import_rxjs5.from)(withActorSpan("browser", name, () => handler(event)))
+        (event) => (0, import_rxjs5.from)(withActorSpan("browser", name, () => handler(event))).pipe(
+          // Isolate per-event failures: a single handler throw must NOT tear down the
+          // channel subscription for every future request — that's the browse:entity-types
+          // wedge (.plans/bugs/browse-entity-types-never-responds.md). Handlers emit their
+          // own *-failed reply; this is the structural backstop for any throw that escapes a
+          // handler's try/catch — the channel survives, the offending request is logged.
+          // (A per-channel *-failed can't be emitted from this generic helper without the
+          // request→failure mapping — that's the Tier 1 operations registry.)
+          (0, import_operators5.catchError)((error) => {
+            this.logger.error(`browse handler threw on ${name}`, { error: errField(error) });
+            return import_rxjs5.EMPTY;
+          })
+        )
       )
     );
     this.subscriptions.push(
@@ -11834,6 +11959,7 @@ var Browser = class {
       pipe("browse:referenced-by-requested", (e) => this.handleReferencedBy(e)).subscribe({ error: errorHandler }),
       pipe("browse:entity-types-requested", (e) => this.handleEntityTypes(e)).subscribe({ error: errorHandler }),
       pipe("browse:tag-schemas-requested", (e) => this.handleTagSchemas(e)).subscribe({ error: errorHandler }),
+      pipe("browse:agents-requested", (e) => this.handleBrowseAgents(e)).subscribe({ error: errorHandler }),
       pipe("browse:directory-requested", (e) => this.handleBrowseDirectory(e)).subscribe({ error: errorHandler })
     );
   }
@@ -12082,6 +12208,21 @@ var Browser = class {
       });
     }
   }
+  async handleBrowseAgents(event) {
+    try {
+      const agents = deriveAgentRoster(this.config);
+      this.eventBus.get("browse:agents-result").next({
+        correlationId: event.correlationId,
+        response: { agents }
+      });
+    } catch (error) {
+      this.logger.error("Agent roster derivation failed", { error: errField(error) });
+      this.eventBus.get("browse:agents-failed").next({
+        correlationId: event.correlationId,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   // ========================================================================
   // Filesystem read handler
   // ========================================================================
@@ -12206,49 +12347,48 @@ async function readAnnotationFromView(kb, resourceId10, annotationId5) {
 }
 
 // src/clone-token-manager.ts
-var import_rxjs7 = __toESM(require_cjs());
-var import_operators7 = __toESM(require_operators());
-
-// src/resource-operations.ts
 var import_rxjs6 = __toESM(require_cjs());
 var import_operators6 = __toESM(require_operators());
+
+// src/bus-request-local.ts
+function asBusRequestPrimitive(eventBus) {
+  return {
+    emit(channel, payload) {
+      eventBus.get(channel).next(payload);
+      return Promise.resolve();
+    },
+    stream(channel) {
+      return eventBus.get(channel).asObservable();
+    }
+  };
+}
+
+// src/resource-operations.ts
 var ResourceOperations = class {
   /**
    * Create a new resource via EventBus → Stower
    */
   static async createResource(input, userId3, eventBus) {
-    const result$ = (0, import_rxjs6.race)(
-      eventBus.get("yield:create-ok").pipe(
-        (0, import_operators6.take)(1),
-        (0, import_operators6.map)((result) => ({ ok: true, result }))
-      ),
-      eventBus.get("yield:create-failed").pipe(
-        (0, import_operators6.take)(1),
-        (0, import_operators6.map)((failure) => ({ ok: false, error: new Error(failure.message) }))
-      ),
-      (0, import_rxjs6.timer)(3e4).pipe(
-        (0, import_operators6.map)(() => ({ ok: false, error: new Error("Resource creation timed out") }))
-      )
+    const { resourceId: rId } = await busRequest(
+      asBusRequestPrimitive(eventBus),
+      "yield:create",
+      {
+        name: input.name,
+        storageUri: input.storageUri,
+        contentChecksum: input.contentChecksum,
+        byteSize: input.byteSize,
+        format: input.format,
+        _userId: userId3,
+        language: input.language,
+        entityTypes: input.entityTypes,
+        generatedFrom: input.generatedFrom,
+        generationPrompt: input.generationPrompt,
+        generator: input.generator,
+        isDraft: input.isDraft
+      },
+      3e4
     );
-    eventBus.get("yield:create").next({
-      name: input.name,
-      storageUri: input.storageUri,
-      contentChecksum: input.contentChecksum,
-      byteSize: input.byteSize,
-      format: input.format,
-      _userId: userId3,
-      language: input.language,
-      entityTypes: input.entityTypes,
-      generatedFrom: input.generatedFrom,
-      generationPrompt: input.generationPrompt,
-      generator: input.generator,
-      isDraft: input.isDraft
-    });
-    const outcome = await (0, import_rxjs6.firstValueFrom)(result$);
-    if (!outcome.ok) {
-      throw outcome.error;
-    }
-    return resourceId(outcome.result.resourceId);
+    return resourceId(rId);
   }
 };
 
@@ -12268,13 +12408,13 @@ var CloneTokenManager = class {
     this.logger.info("CloneTokenManager actor initialized");
     const errorHandler = (err) => this.logger.error("CloneTokenManager pipeline error", { error: err });
     const generateToken$ = this.eventBus.get("yield:clone-token-requested").pipe(
-      (0, import_operators7.mergeMap)((event) => (0, import_rxjs7.from)(this.handleGenerateToken(event)))
+      (0, import_operators6.mergeMap)((event) => (0, import_rxjs6.from)(this.handleGenerateToken(event)))
     );
     const getResource$ = this.eventBus.get("yield:clone-resource-requested").pipe(
-      (0, import_operators7.mergeMap)((event) => (0, import_rxjs7.from)(this.handleGetResource(event)))
+      (0, import_operators6.mergeMap)((event) => (0, import_rxjs6.from)(this.handleGetResource(event)))
     );
     const createResource$ = this.eventBus.get("yield:clone-create").pipe(
-      (0, import_operators7.mergeMap)((event) => (0, import_rxjs7.from)(this.handleCreateResource(event)))
+      (0, import_operators6.mergeMap)((event) => (0, import_rxjs6.from)(this.handleCreateResource(event)))
     );
     this.subscriptions.push(
       generateToken$.subscribe({ error: errorHandler }),
@@ -12448,10 +12588,6 @@ var CloneTokenManager = class {
     this.logger.info("CloneTokenManager actor stopped");
   }
 };
-
-// src/bootstrap/entity-types.ts
-var import_rxjs8 = __toESM(require_cjs());
-var import_operators8 = __toESM(require_operators());
 async function bootstrapEntityTypes(eventBus, eventStore, logger) {
   const systemEvents = await eventStore.log.getEvents(resourceId("__system__"));
   const existingTypes = new Set(
@@ -12466,16 +12602,12 @@ async function bootstrapEntityTypes(eventBus, eventStore, logger) {
   const SYSTEM_USER_ID = userId("00000000-0000-0000-0000-000000000000");
   for (const entityType2 of missing) {
     logger?.debug("Adding entity type via EventBus", { entityType: entityType2 });
-    const result$ = (0, import_rxjs8.race)(
-      eventBus.get("frame:entity-type-added").pipe((0, import_operators8.take)(1), (0, import_operators8.map)(() => ({ ok: true }))),
-      eventBus.get("frame:entity-type-add-failed").pipe((0, import_operators8.take)(1), (0, import_operators8.map)((f) => ({ ok: false, error: new Error(f.message) }))),
-      (0, import_rxjs8.timer)(1e4).pipe((0, import_operators8.map)(() => ({ ok: false, error: new Error(`Timeout adding entity type: ${entityType2}`) })))
+    await busRequest(
+      asBusRequestPrimitive(eventBus),
+      "frame:add-entity-type",
+      { tag: entityType2, _userId: SYSTEM_USER_ID },
+      1e4
     );
-    eventBus.get("frame:add-entity-type").next({ tag: entityType2, _userId: SYSTEM_USER_ID });
-    const outcome = await (0, import_rxjs8.firstValueFrom)(result$);
-    if (!outcome.ok) {
-      throw outcome.error;
-    }
   }
   logger?.info("Entity types bootstrap completed", { added: missing.length, total: DEFAULT_ENTITY_TYPES.length });
 }
@@ -12636,10 +12768,7 @@ function registerBindUpdateBodyHandler(eventBus, parentLogger) {
     if (!cid || !inflight.has(cid)) return;
     inflight.delete(cid);
     const annId = event.payload?.annotationId;
-    eventBus.get("bind:body-updated").next({
-      correlationId: cid,
-      annotationId: annId
-    });
+    eventBus.get("bind:body-updated").next({ correlationId: cid });
     logger.info("Bind body-updated confirmed", { annotationId: annId, correlationId: cid });
   });
   eventBus.get("mark:body-update-failed").subscribe((event) => {
@@ -12654,31 +12783,6 @@ function registerBindUpdateBodyHandler(eventBus, parentLogger) {
     logger.warn("Bind body-update failed after forwarding", { correlationId: cid, message });
   });
 }
-
-// src/views/projection-validators.ts
-function resolveTagSchema(tagSchemas, schemaId) {
-  if (typeof schemaId !== "string" || !schemaId) {
-    return { error: "tag-annotation requires schemaId" };
-  }
-  const schema = tagSchemas.find((s) => s.id === schemaId);
-  if (!schema) {
-    return { error: `Tag schema not registered: ${schemaId}` };
-  }
-  return { schema };
-}
-function validateEntityTypes(registered, requested) {
-  if (!requested || requested.length === 0) {
-    return { ok: true };
-  }
-  const set = new Set(registered);
-  const unknown = requested.filter((t) => !set.has(t));
-  return unknown.length > 0 ? { ok: false, unknown } : { ok: true };
-}
-function entityTypesNotRegisteredMessage(unknown) {
-  return `Entity type not registered: ${unknown.join(", ")}`;
-}
-
-// src/handlers/job-commands.ts
 function parseDidUser(did) {
   const parts = did.split(":");
   const usersIdx = parts.indexOf("users");
@@ -12706,7 +12810,11 @@ function registerJobCommandHandlers(eventBus, jobQueue, project, parentLogger) {
           userDomain: user.domain,
           created: (/* @__PURE__ */ new Date()).toISOString(),
           retryCount: 0,
-          maxRetries: jobType === "generation" ? 3 : 1
+          // Generation is non-idempotent — a retry re-runs the LLM and produces
+          // *different* content (not a replay) — and expensive. Surface the failure
+          // to the caller rather than silently re-rolling. Detection jobs re-scan the
+          // same content (≈idempotent) and keep one self-heal retry.
+          maxRetries: jobType === "generation" ? 0 : 1
         },
         params: {
           resourceId: resourceId(resId),
@@ -12823,11 +12931,19 @@ function registerJobCommandHandlers(eventBus, jobQueue, project, parentLogger) {
     try {
       const cancelled = await jobQueue.cancelPendingJobs(event.jobType);
       logger.info("Cancel requested", { jobType: event.jobType, cancelled });
+      eventBus.get("job:cancel-ok").next({
+        correlationId: event.correlationId,
+        response: { cancelled }
+      });
     } catch (error) {
       logger.error("Failed to cancel pending jobs", {
         jobType: event.jobType,
         error: error.message
       });
+      eventBus.get("job:cancel-failed").next({
+        correlationId: event.correlationId,
+        message: error.message
+      });
     }
   });
 }
@@ -12847,7 +12963,7 @@ async function createJobQueue(project, eventBus, logger) {
   await jobQueue.initialize();
   registerJobQueueProvider(() => jobQueue.getStats());
   const jobStatusSubscription = eventBus.get("job:status-requested").pipe(
-    (0, import_operators9.mergeMap)((event) => (0, import_rxjs9.from)((async () => {
+    (0, import_operators7.mergeMap)((event) => (0, import_rxjs7.from)((async () => {
       try {
         const job = await jobQueue.getJob(jobId(event.jobId));
         if (!job) {
@@ -12917,7 +13033,7 @@ async function createKnowledgeSystemFromConfig(project, config, eventBus, logger
     if (annotation === null) return event;
     return { ...event, annotation };
   });
-  const stower = new Stower(kb, eventBus, logger.child({ component: "stower" }));
+  const stower = new Stower(kb, eventBus, project, logger.child({ component: "stower" }));
   await stower.initialize();
   await bootstrapEntityTypes(eventBus, eventStore, logger.child({ component: "entity-types-bootstrap" }));
   const gatherer = new Gatherer(
@@ -12936,7 +13052,7 @@ async function createKnowledgeSystemFromConfig(project, config, eventBus, logger
     embeddingProvider
   );
   await matcher.initialize();
-  const browser = new Browser(kb.views, kb, eventBus, project, logger.child({ component: "browser" }));
+  const browser = new Browser(kb.views, kb, eventBus, project, config, logger.child({ component: "browser" }));
   await browser.initialize();
   const cloneTokenManager = new CloneTokenManager(kb, eventBus, logger.child({ component: "clone-token-manager" }));
   await cloneTokenManager.initialize();
@@ -12964,11 +13080,11 @@ async function startMakeMeaning(project, config, eventBus, logger, options) {
 }
 
 // src/local-transport.ts
-var import_rxjs10 = __toESM(require_cjs());
+var import_rxjs8 = __toESM(require_cjs());
 var LocalTransport = class {
   baseUrl;
   state$;
-  errorsSubject = new import_rxjs10.Subject();
+  errorsSubject = new import_rxjs8.Subject();
   /**
    * Stream of `SemiontError` instances surfaced from transport-mediated
    * round-trips (typed-wire methods on this transport that fail). The
@@ -12989,7 +13105,7 @@ var LocalTransport = class {
     this.bus = cfg.eventBus;
     this.userId = cfg.userId;
     this.baseUrl = cfg.baseUrl ?? baseUrl("local://in-process");
-    this.state$ = new import_rxjs10.BehaviorSubject("open");
+    this.state$ = new import_rxjs8.BehaviorSubject("open");
   }
   // ── Bus primitives ──────────────────────────────────────────────────────
   async emit(channel, payload, resourceScope) {
@@ -13122,8 +13238,8 @@ var LocalContentTransport = class {
 };
 
 // src/smelter.ts
-var import_rxjs11 = __toESM(require_cjs());
-var import_operators10 = __toESM(require_operators());
+var import_rxjs9 = __toESM(require_cjs());
+var import_operators8 = __toESM(require_operators());
 function isWorkItem(input) {
   return input.type.startsWith("smelt:");
 }
@@ -13149,7 +13265,7 @@ var Smelter = class _Smelter {
   static RECONCILE_PAGE_SIZE = 200;
   /** Bound on concurrently in-flight reconcile work — a cold rebuild must not fan out unbounded embedding calls. */
   static RECONCILE_WAVE = 8;
-  eventSubject = new import_rxjs11.Subject();
+  eventSubject = new import_rxjs9.Subject();
   sourceSubscription = null;
   pipelineSubscription = null;
   _eventsProcessed = 0;
@@ -13164,23 +13280,23 @@ var Smelter = class _Smelter {
   }
   initialize() {
     this.pipelineSubscription = this.eventSubject.pipe(
-      (0, import_operators10.groupBy)((e) => e.resourceId ?? "__unknown__"),
-      (0, import_operators10.mergeMap)(
+      (0, import_operators8.groupBy)((e) => e.resourceId ?? "__unknown__"),
+      (0, import_operators8.mergeMap)(
         (group) => group.pipe(
           burstBuffer({
             burstWindowMs: this.timing.burstWindowMs,
             maxBatchSize: this.timing.maxBatchSize,
             idleTimeoutMs: this.timing.idleTimeoutMs
           }),
-          (0, import_operators10.concatMap)((inputOrBatch) => {
+          (0, import_operators8.concatMap)((inputOrBatch) => {
             if (Array.isArray(inputOrBatch)) {
-              return (0, import_rxjs11.from)(
+              return (0, import_rxjs9.from)(
                 withActorSpan("smelter", "batch", async () => {
                   this._eventsProcessed += await this.processBatch(inputOrBatch);
                 }, { "batch.size": inputOrBatch.length })
               );
             }
-            return (0, import_rxjs11.from)(
+            return (0, import_rxjs9.from)(
               withActorSpan("smelter", inputOrBatch.type, async () => {
                 const ok = await this.safeProcessEvent(inputOrBatch);
                 if (isWorkItem(inputOrBatch)) this.noteWorkDone(1);
@@ -13339,6 +13455,23 @@ var Smelter = class _Smelter {
       return null;
     }
   }
+  /**
+   * Read a resource's current entity types from the materialized view — the
+   * authoritative source, updated before the EventBus fires to consumers — so
+   * its vectors carry the discriminator `searchResources` filters on (e.g.
+   * exclude `['Question']`). One read on every embed path, mirroring how the
+   * smelter already reads current content and annotations; a failed read
+   * propagates to the pipeline's per-resource error handler (reconcile heals),
+   * rather than silently stamping `[]` and letting the resource leak into recall.
+   */
+  async resolveEntityTypes(resourceId10) {
+    const { resource } = await busRequest(
+      this.bus,
+      "browse:resource-requested",
+      { resourceId: resourceId10 }
+    );
+    return getResourceEntityTypes(resource);
+  }
   async embedResource(event, logMessage) {
     const rid = event.resourceId;
     if (!rid) return;
@@ -13346,13 +13479,14 @@ var Smelter = class _Smelter {
     if (!fetched) return;
     const chunks = chunkText(fetched.text, this.chunkingConfig);
     if (chunks.length === 0) return;
+    const entityTypes = await this.resolveEntityTypes(rid);
     const embeddings = await this.embeddingProvider.embedBatch(chunks);
     const embeddingChunks = chunks.map((t, i) => ({
       chunkIndex: i,
       text: t,
       embedding: embeddings[i]
     }));
-    await this.vectorStore.upsertResourceVectors(resourceId(rid), embeddingChunks, fetched.checksum);
+    await this.vectorStore.upsertResourceVectors(resourceId(rid), embeddingChunks, fetched.checksum, entityTypes);
     this.logger.info(logMessage, { resourceId: rid, chunks: chunks.length });
   }
   async handleResourceArchived(event) {
@@ -13403,19 +13537,20 @@ var Smelter = class _Smelter {
       if (!fetched) continue;
       const chunks = chunkText(fetched.text, this.chunkingConfig);
       if (chunks.length === 0) continue;
-      resourceData.push({ rid: resourceId(rid), chunks, checksum: fetched.checksum });
+      const entityTypes = await this.resolveEntityTypes(rid);
+      resourceData.push({ rid: resourceId(rid), chunks, checksum: fetched.checksum, entityTypes });
       allChunks.push(...chunks);
     }
     if (allChunks.length === 0) return events.length;
     const allEmbeddings = await this.embeddingProvider.embedBatch(allChunks);
     let offset = 0;
-    for (const { rid, chunks, checksum } of resourceData) {
+    for (const { rid, chunks, checksum, entityTypes } of resourceData) {
       const embeddingChunks = chunks.map((t, i) => ({
         chunkIndex: i,
         text: t,
         embedding: allEmbeddings[offset + i]
       }));
-      await this.vectorStore.upsertResourceVectors(rid, embeddingChunks, checksum);
+      await this.vectorStore.upsertResourceVectors(rid, embeddingChunks, checksum, entityTypes);
       this.logger.info("Batch-indexed resource", { resourceId: String(rid), chunks: chunks.length });
       offset += chunks.length;
     }
@@ -13522,9 +13657,7 @@ var Smelter = class _Smelter {
         const { annotations } = await busRequest(
           this.bus,
           "browse:annotations-requested",
-          { resourceId: rid },
-          "browse:annotations-result",
-          "browse:annotations-failed"
+          { resourceId: rid }
         );
         for (const annotation of annotations) {
           const exactText = getExactText(getTargetSelector(annotation.target));
@@ -13582,9 +13715,7 @@ var Smelter = class _Smelter {
       const page = await busRequest(
         this.bus,
         "browse:resources-requested",
-        { archived: false, offset: all.length, limit: _Smelter.RECONCILE_PAGE_SIZE },
-        "browse:resources-result",
-        "browse:resources-failed"
+        { archived: false, offset: all.length, limit: _Smelter.RECONCILE_PAGE_SIZE }
       );
       all.push(...page.resources);
       if (page.resources.length === 0 || all.length >= page.total) return all;
@@ -13593,8 +13724,8 @@ var Smelter = class _Smelter {
 };
 
 // src/smelter-actor-state-unit.ts
-var import_rxjs12 = __toESM(require_cjs());
-var import_operators11 = __toESM(require_operators());
+var import_rxjs10 = __toESM(require_cjs());
+var import_operators9 = __toESM(require_operators());
 var SMELTER_CHANNELS = [
   "yield:created",
   "yield:updated",
@@ -13606,10 +13737,10 @@ var SMELTER_CHANNELS = [
 function createSmelterActorStateUnit(options) {
   const { bus } = options;
   let started = false;
-  const events$ = (0, import_rxjs12.merge)(
+  const events$ = (0, import_rxjs10.merge)(
     ...SMELTER_CHANNELS.map(
       (channel) => bus.on$(channel).pipe(
-        (0, import_operators11.map)((payload) => ({
+        (0, import_operators9.map)((payload) => ({
           type: channel,
           resourceId: payload.resourceId,
           payload
@@ -13812,11 +13943,28 @@ function collectContentRefs(streamData) {
   return refs;
 }
 
-// src/exchange/replay.ts
-var import_rxjs13 = __toESM(require_cjs());
-var import_operators12 = __toESM(require_operators());
+// src/exchange/await-reply.ts
+var import_rxjs11 = __toESM(require_cjs());
+var import_operators10 = __toESM(require_operators());
+function awaitReply(eventBus, command, payload, okChannel, failedChannel, timeoutMs) {
+  const result$ = (0, import_rxjs11.race)(
+    eventBus.get(okChannel).pipe((0, import_operators10.map)(() => void 0)),
+    eventBus.get(failedChannel).pipe(
+      (0, import_operators10.map)((e) => {
+        throw new Error(e.message ?? `${command} failed`);
+      })
+    ),
+    (0, import_rxjs11.timer)(timeoutMs).pipe(
+      (0, import_operators10.map)(() => {
+        throw new Error(`Timeout waiting for ${okChannel}`);
+      })
+    )
+  );
+  eventBus.get(command).next(payload);
+  return (0, import_rxjs11.firstValueFrom)(result$);
+}
 var REPLAY_TIMEOUT_MS = 3e4;
-async function replayEventStream(jsonl, eventBus, resolveBlob, contentStore, logger) {
+async function replayEventStream(jsonl, eventBus, eventStore, resolveBlob, contentStore, logger) {
   const lines = jsonl.trim().split("\n").filter((l) => l.length > 0);
   const storedEvents = lines.map((line) => JSON.parse(line));
   const stats = {
@@ -13826,12 +13974,12 @@ async function replayEventStream(jsonl, eventBus, resolveBlob, contentStore, log
     entityTypesAdded: 0
   };
   for (const stored of storedEvents) {
-    await replayEvent(stored, eventBus, resolveBlob, contentStore, stats, logger);
+    await replayEvent(stored, eventBus, eventStore, resolveBlob, contentStore, stats, logger);
     stats.eventsReplayed++;
   }
   return { stats };
 }
-async function replayEvent(event, eventBus, resolveBlob, contentStore, stats, logger) {
+async function replayEvent(event, eventBus, eventStore, resolveBlob, contentStore, stats, logger) {
   switch (event.type) {
     case "frame:entity-type-added":
       await replayEntityTypeAdded(event, eventBus, logger);
@@ -13859,7 +14007,7 @@ async function replayEvent(event, eventBus, resolveBlob, contentStore, stats, lo
       break;
     case "mark:entity-tag-added":
     case "mark:entity-tag-removed":
-      await replayEntityTagChange(event, eventBus, logger);
+      await replayEntityTagChange(event, eventStore, logger);
       break;
     // Job events are transient — skip during replay
     case "job:started":
@@ -13878,20 +14026,12 @@ async function replayEvent(event, eventBus, resolveBlob, contentStore, stats, lo
   }
 }
 async function replayEntityTypeAdded(event, eventBus, logger) {
-  const result$ = (0, import_rxjs13.race)(
-    eventBus.get("frame:entity-type-added").pipe((0, import_operators12.map)(() => "ok")),
-    eventBus.get("frame:entity-type-add-failed").pipe((0, import_operators12.map)((e) => {
-      throw new Error(e.message);
-    })),
-    (0, import_rxjs13.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators12.map)(() => {
-      throw new Error("Timeout waiting for frame:entity-type-added");
-    }))
+  await busRequest(
+    asBusRequestPrimitive(eventBus),
+    "frame:add-entity-type",
+    { tag: event.payload.entityType, _userId: event.userId },
+    REPLAY_TIMEOUT_MS
   );
-  eventBus.get("frame:add-entity-type").next({
-    tag: event.payload.entityType,
-    _userId: event.userId
-  });
-  await (0, import_rxjs13.firstValueFrom)(result$);
   logger?.debug("Replayed entitytype.added", { entityType: event.payload.entityType });
 }
 async function replayResourceCreated(event, eventBus, resolveBlob, contentStore, logger) {
@@ -13903,84 +14043,70 @@ async function replayResourceCreated(event, eventBus, resolveBlob, contentStore,
   const base = baseMediaType(payload.format);
   const resolvedUri = payload.storageUri || deriveStorageUri(payload.name, isSupportedMediaType(base) ? base : "application/octet-stream");
   const stored = await contentStore.store(blob, resolvedUri);
-  const result$ = (0, import_rxjs13.race)(
-    eventBus.get("yield:create-ok").pipe((0, import_operators12.map)((r) => r)),
-    eventBus.get("yield:create-failed").pipe((0, import_operators12.map)((e) => {
-      throw new Error(e.message);
-    })),
-    (0, import_rxjs13.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators12.map)(() => {
-      throw new Error("Timeout waiting for yield:create-ok");
-    }))
+  await busRequest(
+    asBusRequestPrimitive(eventBus),
+    "yield:create",
+    {
+      name: payload.name,
+      storageUri: resolvedUri,
+      contentChecksum: stored.checksum,
+      byteSize: stored.byteSize,
+      format: payload.format,
+      _userId: event.userId,
+      language: payload.language,
+      entityTypes: payload.entityTypes,
+      isDraft: payload.isDraft,
+      generatedFrom: payload.generatedFrom,
+      generationPrompt: payload.generationPrompt
+    },
+    REPLAY_TIMEOUT_MS
   );
-  eventBus.get("yield:create").next({
-    name: payload.name,
-    storageUri: resolvedUri,
-    contentChecksum: stored.checksum,
-    byteSize: stored.byteSize,
-    format: payload.format,
-    _userId: event.userId,
-    language: payload.language,
-    entityTypes: payload.entityTypes,
-    isDraft: payload.isDraft,
-    generatedFrom: payload.generatedFrom,
-    generationPrompt: payload.generationPrompt
-  });
-  await (0, import_rxjs13.firstValueFrom)(result$);
   logger?.debug("Replayed resource.created", { name: payload.name });
 }
 async function replayAnnotationAdded(event, eventBus, logger) {
-  const result$ = (0, import_rxjs13.race)(
-    eventBus.get("mark:create-ok").pipe((0, import_operators12.map)(() => "ok")),
-    eventBus.get("mark:create-failed").pipe((0, import_operators12.map)((e) => {
-      throw new Error(e.message);
-    })),
-    (0, import_rxjs13.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators12.map)(() => {
-      throw new Error("Timeout waiting for mark:create-ok");
-    }))
+  await awaitReply(
+    eventBus,
+    "mark:create",
+    {
+      annotation: event.payload.annotation,
+      _userId: event.userId,
+      resourceId: event.resourceId
+    },
+    "mark:create-ok",
+    "mark:create-failed",
+    REPLAY_TIMEOUT_MS
   );
-  eventBus.get("mark:create").next({
-    annotation: event.payload.annotation,
-    _userId: event.userId,
-    resourceId: event.resourceId
-  });
-  await (0, import_rxjs13.firstValueFrom)(result$);
   logger?.debug("Replayed annotation.added", { annotationId: event.payload.annotation.id });
 }
 async function replayAnnotationBodyUpdated(event, eventBus, logger) {
-  const result$ = (0, import_rxjs13.race)(
-    eventBus.get("mark:body-updated").pipe((0, import_operators12.map)(() => "ok")),
-    eventBus.get("mark:body-update-failed").pipe((0, import_operators12.map)((e) => {
-      throw new Error(e.message);
-    })),
-    (0, import_rxjs13.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators12.map)(() => {
-      throw new Error("Timeout waiting for mark:body-updated");
-    }))
+  await awaitReply(
+    eventBus,
+    "mark:update-body",
+    {
+      annotationId: event.payload.annotationId,
+      _userId: event.userId,
+      resourceId: event.resourceId,
+      operations: event.payload.operations
+    },
+    "mark:body-updated",
+    "mark:body-update-failed",
+    REPLAY_TIMEOUT_MS
   );
-  eventBus.get("mark:update-body").next({
-    annotationId: event.payload.annotationId,
-    _userId: event.userId,
-    resourceId: event.resourceId,
-    operations: event.payload.operations
-  });
-  await (0, import_rxjs13.firstValueFrom)(result$);
   logger?.debug("Replayed annotation.body.updated", { annotationId: event.payload.annotationId });
 }
 async function replayAnnotationRemoved(event, eventBus, logger) {
-  const result$ = (0, import_rxjs13.race)(
-    eventBus.get("mark:delete-ok").pipe((0, import_operators12.map)(() => "ok")),
-    eventBus.get("mark:delete-failed").pipe((0, import_operators12.map)((e) => {
-      throw new Error(e.message);
-    })),
-    (0, import_rxjs13.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators12.map)(() => {
-      throw new Error("Timeout waiting for mark:delete-ok");
-    }))
+  await awaitReply(
+    eventBus,
+    "mark:delete",
+    {
+      annotationId: event.payload.annotationId,
+      _userId: event.userId,
+      resourceId: event.resourceId
+    },
+    "mark:delete-ok",
+    "mark:delete-failed",
+    REPLAY_TIMEOUT_MS
   );
-  eventBus.get("mark:delete").next({
-    annotationId: event.payload.annotationId,
-    _userId: event.userId,
-    resourceId: event.resourceId
-  });
-  await (0, import_rxjs13.firstValueFrom)(result$);
   logger?.debug("Replayed annotation.removed", { annotationId: event.payload.annotationId });
 }
 async function replayResourceArchived(event, eventBus, logger) {
@@ -13997,25 +14123,18 @@ async function replayResourceUnarchived(event, eventBus, logger) {
   });
   logger?.debug("Replayed resource.unarchived", { resourceId: event.resourceId });
 }
-async function replayEntityTagChange(event, eventBus, logger) {
-  const resourceId10 = event.resourceId;
-  const entityType2 = event.payload.entityType;
+async function replayEntityTagChange(event, eventStore, logger) {
+  const base = {
+    resourceId: event.resourceId,
+    userId: event.userId,
+    version: event.version
+  };
   if (event.type === "mark:entity-tag-added") {
-    eventBus.get("mark:update-entity-types").next({
-      resourceId: resourceId10,
-      _userId: event.userId,
-      currentEntityTypes: [],
-      updatedEntityTypes: [entityType2]
-    });
+    await eventStore.appendEvent({ ...base, type: "mark:entity-tag-added", payload: event.payload });
   } else {
-    eventBus.get("mark:update-entity-types").next({
-      resourceId: resourceId10,
-      _userId: event.userId,
-      currentEntityTypes: [entityType2],
-      updatedEntityTypes: []
-    });
+    await eventStore.appendEvent({ ...base, type: "mark:entity-tag-removed", payload: event.payload });
   }
-  logger?.debug("Replayed entity tag change", { type: event.type, entityType: entityType2 });
+  logger?.debug("Replayed entity tag change", { type: event.type, entityType: event.payload.entityType });
 }
 
 // src/exchange/backup-importer.ts
@@ -14034,7 +14153,7 @@ function buildBlobResolver(entries) {
   };
 }
 async function importBackup(archive, options) {
-  const { eventBus, contentStore, logger } = options;
+  const { eventBus, eventStore, contentStore, logger } = options;
   const entries = /* @__PURE__ */ new Map();
   for await (const entry of readTarGz(archive)) {
     entries.set(entry.name, entry.data);
@@ -14062,6 +14181,7 @@ async function importBackup(archive, options) {
     const result = await replayEventStream(
       systemData.toString("utf8"),
       eventBus,
+      eventStore,
       resolveBlob,
       contentStore,
       logger
@@ -14078,6 +14198,7 @@ async function importBackup(archive, options) {
     const result = await replayEventStream(
       eventData.toString("utf8"),
       eventBus,
+      eventStore,
       resolveBlob,
       contentStore,
       logger
@@ -14263,10 +14384,6 @@ function collectContentRefsFromResource(resource, refs) {
     refs.set(resource.storageUri, mediaType);
   }
 }
-
-// src/exchange/linked-data-importer.ts
-var import_rxjs14 = __toESM(require_cjs());
-var import_operators13 = __toESM(require_operators());
 var IMPORT_TIMEOUT_MS = 3e4;
 function stripUriToId(uri) {
   if (!uri.includes("/")) return uri;
@@ -14368,20 +14485,12 @@ async function importLinkedData(archive, options) {
   };
 }
 async function addEntityType(entityType2, userId3, eventBus, logger) {
-  const result$ = (0, import_rxjs14.race)(
-    eventBus.get("frame:entity-type-added").pipe((0, import_operators13.map)(() => "ok")),
-    eventBus.get("frame:entity-type-add-failed").pipe((0, import_operators13.map)((e) => {
-      throw new Error(e.message);
-    })),
-    (0, import_rxjs14.timer)(IMPORT_TIMEOUT_MS).pipe((0, import_operators13.map)(() => {
-      throw new Error("Timeout waiting for frame:entity-type-added");
-    }))
+  await busRequest(
+    asBusRequestPrimitive(eventBus),
+    "frame:add-entity-type",
+    { tag: entityType2, _userId: userId3 },
+    IMPORT_TIMEOUT_MS
   );
-  eventBus.get("frame:add-entity-type").next({
-    tag: entityType2,
-    _userId: userId3
-  });
-  await (0, import_rxjs14.firstValueFrom)(result$);
   logger?.debug("Added entity type", { entityType: entityType2 });
 }
 async function importResource(doc, userId3, eventBus, contentStore, resolveBlob, logger) {
@@ -14408,27 +14517,22 @@ async function importResource(doc, userId3, eventBus, contentStore, resolveBlob,
   const base = baseMediaType(format);
   const resolvedUri = deriveStorageUri(name, isSupportedMediaType(base) ? base : "application/octet-stream");
   const stored = await contentStore.store(blob, resolvedUri);
-  const createResult$ = (0, import_rxjs14.race)(
-    eventBus.get("yield:create-ok").pipe((0, import_operators13.map)((r) => r)),
-    eventBus.get("yield:create-failed").pipe((0, import_operators13.map)((e) => {
-      throw new Error(e.message);
-    })),
-    (0, import_rxjs14.timer)(IMPORT_TIMEOUT_MS).pipe((0, import_operators13.map)(() => {
-      throw new Error("Timeout waiting for yield:create-ok");
-    }))
+  const { resourceId: createdId } = await busRequest(
+    asBusRequestPrimitive(eventBus),
+    "yield:create",
+    {
+      name,
+      storageUri: resolvedUri,
+      contentChecksum: stored.checksum,
+      byteSize: stored.byteSize,
+      format,
+      _userId: userId3,
+      language,
+      entityTypes: entityTypes ?? []
+    },
+    IMPORT_TIMEOUT_MS
   );
-  eventBus.get("yield:create").next({
-    name,
-    storageUri: resolvedUri,
-    contentChecksum: stored.checksum,
-    byteSize: stored.byteSize,
-    format,
-    _userId: userId3,
-    language,
-    entityTypes: entityTypes ?? []
-  });
-  const created = await (0, import_rxjs14.firstValueFrom)(createResult$);
-  const resourceId10 = resourceId(created.resourceId);
+  const resourceId10 = resourceId(createdId);
   logger?.debug("Created resource from JSON-LD", { name, resourceId: resourceId10 });
   let annotationsCreated = 0;
   if (annotations && annotations.length > 0) {
@@ -14440,21 +14544,18 @@ async function importResource(doc, userId3, eventBus, contentStore, resolveBlob,
   return { annotationsCreated };
 }
 async function createAnnotation(annotation, resourceId10, userId3, eventBus, logger) {
-  const result$ = (0, import_rxjs14.race)(
-    eventBus.get("mark:create-ok").pipe((0, import_operators13.map)(() => "ok")),
-    eventBus.get("mark:create-failed").pipe((0, import_operators13.map)((e) => {
-      throw new Error(e.message);
-    })),
-    (0, import_rxjs14.timer)(IMPORT_TIMEOUT_MS).pipe((0, import_operators13.map)(() => {
-      throw new Error("Timeout waiting for mark:create-ok");
-    }))
+  await awaitReply(
+    eventBus,
+    "mark:create",
+    {
+      annotation: dehydrateAnnotation(annotation),
+      _userId: userId3,
+      resourceId: resourceId10
+    },
+    "mark:create-ok",
+    "mark:create-failed",
+    IMPORT_TIMEOUT_MS
   );
-  eventBus.get("mark:create").next({
-    annotation: dehydrateAnnotation(annotation),
-    _userId: userId3,
-    resourceId: resourceId10
-  });
-  await (0, import_rxjs14.firstValueFrom)(result$);
   logger?.debug("Created annotation", { annotationId: annotation.id });
 }
 var AnnotationOperations = class {