@semiont/make-meaning 0.4.21 → 0.5.0

package/dist/index.js

@@ -1399,26 +1399,26 @@ var require_BehaviorSubject = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.BehaviorSubject = void 0;
     var Subject_1 = require_Subject();
-    var BehaviorSubject = (function(_super) {
-      __extends(BehaviorSubject2, _super);
-      function BehaviorSubject2(_value) {
+    var BehaviorSubject2 = (function(_super) {
+      __extends(BehaviorSubject3, _super);
+      function BehaviorSubject3(_value) {
         var _this = _super.call(this) || this;
         _this._value = _value;
         return _this;
       }
-      Object.defineProperty(BehaviorSubject2.prototype, "value", {
+      Object.defineProperty(BehaviorSubject3.prototype, "value", {
         get: function() {
           return this.getValue();
         },
         enumerable: false,
         configurable: true
       });
-      BehaviorSubject2.prototype._subscribe = function(subscriber) {
+      BehaviorSubject3.prototype._subscribe = function(subscriber) {
         var subscription = _super.prototype._subscribe.call(this, subscriber);
         !subscription.closed && subscriber.next(this._value);
         return subscription;
       };
-      BehaviorSubject2.prototype.getValue = function() {
+      BehaviorSubject3.prototype.getValue = function() {
         var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, _value = _a._value;
         if (hasError) {
           throw thrownError;
@@ -1426,12 +1426,12 @@ var require_BehaviorSubject = __commonJS({
         this._throwIfClosed();
         return _value;
       };
-      BehaviorSubject2.prototype.next = function(value) {
+      BehaviorSubject3.prototype.next = function(value) {
         _super.prototype.next.call(this, this._value = value);
       };
-      return BehaviorSubject2;
+      return BehaviorSubject3;
     })(Subject_1.Subject);
-    exports.BehaviorSubject = BehaviorSubject;
+    exports.BehaviorSubject = BehaviorSubject2;
   }
 });
 
@@ -9945,7 +9945,8 @@ var require_operators = __commonJS({
 // src/service.ts
 import { FsJobQueue } from "@semiont/jobs";
 import { createEventStore as createEventStoreCore } from "@semiont/event-sourcing";
-import { jobId } from "@semiont/core";
+import { jobId as jobId2 } from "@semiont/core";
+import { registerJobQueueProvider } from "@semiont/observability";
 
 // src/config.ts
 function resolveActorInference(config, actor) {
@@ -10314,20 +10315,20 @@ var GraphDBConsumer = class _GraphDBConsumer {
    * Rebuild entire resource from events.
    * Bypasses the live pipeline — reads directly from event store.
    */
-  async rebuildResource(resourceId7) {
+  async rebuildResource(resourceId10) {
     const graphDb = this.ensureInitialized();
-    this.logger.info("Rebuilding resource from events", { resourceId: resourceId7 });
+    this.logger.info("Rebuilding resource from events", { resourceId: resourceId10 });
     try {
-      await graphDb.deleteResource(resourceId7);
+      await graphDb.deleteResource(resourceId10);
     } catch (error) {
-      this.logger.debug("No existing resource to delete", { resourceId: resourceId7 });
+      this.logger.debug("No existing resource to delete", { resourceId: resourceId10 });
     }
     const query = new EventQuery(this.eventStore.log.storage);
-    const events = await query.getResourceEvents(resourceId7);
+    const events = await query.getResourceEvents(resourceId10);
     for (const storedEvent of events) {
       await this.safeApplyEvent(storedEvent);
     }
-    this.logger.info("Resource rebuild complete", { resourceId: resourceId7, eventCount: events.length });
+    this.logger.info("Resource rebuild complete", { resourceId: resourceId10, eventCount: events.length });
   }
   /**
    * Rebuild entire GraphDB from all events.
@@ -10343,8 +10344,8 @@ var GraphDBConsumer = class _GraphDBConsumer {
     const allResourceIds = await this.eventStore.log.getAllResourceIds();
     this.logger.info("Found resources to rebuild", { count: allResourceIds.length });
     this.logger.info("PASS 1: Creating all nodes (resources + annotations)");
-    for (const resourceId7 of allResourceIds) {
-      const events = await query.getResourceEvents(makeResourceId(resourceId7));
+    for (const resourceId10 of allResourceIds) {
+      const events = await query.getResourceEvents(makeResourceId(resourceId10));
       for (const storedEvent of events) {
         if (storedEvent.type === "mark:body-updated") {
           continue;
@@ -10354,8 +10355,8 @@ var GraphDBConsumer = class _GraphDBConsumer {
     }
     this.logger.info("Pass 1 complete - all nodes created");
     this.logger.info("PASS 2: Creating all REFERENCES edges");
-    for (const resourceId7 of allResourceIds) {
-      const events = await query.getResourceEvents(makeResourceId(resourceId7));
+    for (const resourceId10 of allResourceIds) {
+      const events = await query.getResourceEvents(makeResourceId(resourceId10));
       for (const storedEvent of events) {
         if (storedEvent.type === "mark:body-updated") {
           await this.safeApplyEvent(storedEvent);
@@ -10420,6 +10421,7 @@ async function createKnowledgeBase(eventStore, project, graphDb, eventBus, logge
 var import_rxjs2 = __toESM(require_cjs(), 1);
 var import_operators2 = __toESM(require_operators(), 1);
 import { annotationId as makeAnnotationId2, resourceId, errField as errField2 } from "@semiont/core";
+import { withActorSpan } from "@semiont/observability";
 
 // src/generation/resource-generation.ts
 async function generateResourceSummary(resourceName, content, entityTypes, client) {
@@ -10431,10 +10433,10 @@ Resource content:
 ${truncatedContent}
 
 Write a 2-3 sentence summary that captures the key points and would help someone understand what this resource contains.`;
-  return await client.generateText(prompt, 150, 0.5);
+  return client.generateText(prompt, 150, 0.5);
 }
-async function generateReferenceSuggestions(referenceTitle, client, entityType, currentContent) {
-  const prompt = `For a reference titled "${referenceTitle}"${entityType ? ` (type: ${entityType})` : ""}${currentContent ? ` with current stub: "${currentContent}"` : ""}, suggest 3 specific, actionable next steps or related topics to explore.
+async function generateReferenceSuggestions(referenceTitle, client, entityType2, currentContent) {
+  const prompt = `For a reference titled "${referenceTitle}"${entityType2 ? ` (type: ${entityType2})` : ""}${currentContent ? ` with current stub: "${currentContent}"` : ""}, suggest 3 specific, actionable next steps or related topics to explore.
 
 Format as a simple list, one suggestion per line.`;
   const response = await client.generateText(prompt, 200, 0.8);
@@ -10445,27 +10447,18 @@ Format as a simple list, one suggestion per line.`;
 }
 
 // src/annotation-context.ts
-import {
-  getBodySource,
-  getResourceId,
-  getTargetSource,
-  getTargetSelector,
-  getResourceEntityTypes,
-  getTextPositionSelector,
-  getPrimaryRepresentation as getPrimaryRepresentation2,
-  decodeRepresentation as decodeRepresentation2
-} from "@semiont/api-client";
+import { getBodySource, getResourceId, getTargetSource, getTargetSelector, getResourceEntityTypes, getTextPositionSelector, getPrimaryRepresentation as getPrimaryRepresentation2, decodeRepresentation as decodeRepresentation2 } from "@semiont/core";
 import { resourceId as createResourceId } from "@semiont/core";
 import { getEntityTypes } from "@semiont/ontology";
 
 // src/resource-context.ts
-import { getPrimaryRepresentation, decodeRepresentation } from "@semiont/api-client";
+import { getPrimaryRepresentation, decodeRepresentation } from "@semiont/core";
 var ResourceContext = class _ResourceContext {
   /**
    * Get resource metadata from view storage
    */
-  static async getResourceMetadata(resourceId7, kb) {
-    const view = await kb.views.get(resourceId7);
+  static async getResourceMetadata(resourceId10, kb) {
+    const view = await kb.views.get(resourceId10);
     if (!view) {
       return null;
     }
@@ -10510,7 +10503,7 @@ var ResourceContext = class _ResourceContext {
    * Retrieves and decodes the first 200 characters of each resource's primary representation
    */
   static async addContentPreviews(resources, kb) {
-    return await Promise.all(
+    return Promise.all(
       resources.map(async (doc) => {
         try {
           if (doc.storageUri) {
@@ -10553,7 +10546,7 @@ var AnnotationContext = class {
    * @returns Rich context for LLM processing
    * @throws Error if annotation or resource not found
    */
-  static async buildLLMContext(annotationId3, resourceId7, kb, options = {}, inferenceClient, logger, embeddingProvider) {
+  static async buildLLMContext(annotationId5, resourceId10, kb, options = {}, inferenceClient, logger, embeddingProvider) {
     const {
       includeSourceContext = true,
       includeTargetContext = true,
@@ -10562,34 +10555,34 @@ var AnnotationContext = class {
     if (contextWindow < 100 || contextWindow > 5e3) {
       throw new Error("contextWindow must be between 100 and 5000");
     }
-    logger?.debug("Building LLM context", { annotationId: annotationId3, resourceId: resourceId7 });
-    logger?.debug("Getting view for resource", { resourceId: resourceId7 });
+    logger?.debug("Building LLM context", { annotationId: annotationId5, resourceId: resourceId10 });
+    logger?.debug("Getting view for resource", { resourceId: resourceId10 });
     let sourceView;
     try {
-      sourceView = await kb.views.get(resourceId7);
+      sourceView = await kb.views.get(resourceId10);
       logger?.debug("Retrieved view", { hasView: !!sourceView });
       if (!sourceView) {
         throw new Error("Source resource not found");
       }
     } catch (error) {
-      logger?.error("Error getting view", { resourceId: resourceId7, error });
+      logger?.error("Error getting view", { resourceId: resourceId10, error });
       throw error;
     }
     logger?.debug("Looking for annotation in resource", {
-      annotationId: annotationId3,
-      resourceId: resourceId7,
+      annotationId: annotationId5,
+      resourceId: resourceId10,
       totalAnnotations: sourceView.annotations.annotations.length,
       firstFiveIds: sourceView.annotations.annotations.slice(0, 5).map((a) => a.id)
     });
-    const annotation = sourceView.annotations.annotations.find((a) => a.id === annotationId3);
+    const annotation = sourceView.annotations.annotations.find((a) => a.id === annotationId5);
     logger?.debug("Annotation search result", { found: !!annotation });
     if (!annotation) {
       throw new Error("Annotation not found in view");
     }
     const targetSource = getTargetSource(annotation.target);
-    logger?.debug("Validating target resource", { targetSource, expectedResourceId: resourceId7 });
-    if (targetSource !== String(resourceId7)) {
-      throw new Error(`Annotation target resource ID (${targetSource}) does not match expected resource ID (${resourceId7})`);
+    logger?.debug("Validating target resource", { targetSource, expectedResourceId: resourceId10 });
+    if (targetSource !== String(resourceId10)) {
+      throw new Error(`Annotation target resource ID (${targetSource}) does not match expected resource ID (${resourceId10})`);
     }
     const sourceDoc = sourceView.resource;
     const bodySource = getBodySource(annotation.body);
@@ -10653,16 +10646,16 @@ var AnnotationContext = class {
       }
     }
     const suggestedResolution = void 0;
-    logger?.debug("Building graph context", { resourceId: resourceId7 });
+    logger?.debug("Building graph context", { resourceId: resourceId10 });
     const [connections, referencedByAnnotations, entityTypeStats] = await Promise.all([
-      kb.graph.getResourceConnections(resourceId7),
-      kb.graph.getResourceReferencedBy(resourceId7),
+      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(resourceId7)) {
+      if (source && source !== String(resourceId10)) {
         const sourceResId = createResourceId(source);
         const sourceView2 = await kb.views.get(sourceResId);
         if (sourceView2?.resource) {
@@ -10673,7 +10666,7 @@ var AnnotationContext = class {
     const annotationEntityTypes = getEntityTypes(annotation);
     const siblingEntityTypes = /* @__PURE__ */ new Set();
     for (const ann of sourceView.annotations.annotations) {
-      if (ann.id !== annotationId3) {
+      if (ann.id !== annotationId5) {
         for (const et of getEntityTypes(ann)) {
           siblingEntityTypes.add(et);
         }
@@ -10734,7 +10727,7 @@ Summary:`;
         const results = await kb.vectors.searchAnnotations(focalEmbedding, {
           limit: 10,
           scoreThreshold: 0.5,
-          filter: { excludeResourceId: resourceId7 }
+          filter: { excludeResourceId: resourceId10 }
         });
         if (results.length > 0) {
           semanticContext = {
@@ -10786,10 +10779,10 @@ Summary:`;
    * Get resource annotations from view storage (fast path)
    * Throws if view missing
    */
-  static async getResourceAnnotations(resourceId7, kb) {
-    const view = await kb.views.get(resourceId7);
+  static async getResourceAnnotations(resourceId10, kb) {
+    const view = await kb.views.get(resourceId10);
     if (!view) {
-      throw new Error(`Resource ${resourceId7} not found in view storage`);
+      throw new Error(`Resource ${resourceId10} not found in view storage`);
     }
     return view.annotations;
   }
@@ -10797,9 +10790,9 @@ Summary:`;
    * Get all annotations
    * @returns Array of all annotation objects
    */
-  static async getAllAnnotations(resourceId7, kb) {
-    const annotations = await this.getResourceAnnotations(resourceId7, kb);
-    return await this.enrichResolvedReferences(annotations.annotations, kb);
+  static async getAllAnnotations(resourceId10, kb) {
+    const annotations = await this.getResourceAnnotations(resourceId10, kb);
+    return this.enrichResolvedReferences(annotations.annotations, kb);
   }
   /**
    * Enrich reference annotations with resolved document names
@@ -10867,8 +10860,8 @@ Summary:`;
    * Get resource stats (version info)
    * @returns Version and timestamp info for the annotations
    */
-  static async getResourceStats(resourceId7, kb) {
-    const annotations = await this.getResourceAnnotations(resourceId7, kb);
+  static async getResourceStats(resourceId10, kb) {
+    const annotations = await this.getResourceAnnotations(resourceId10, kb);
     return {
       resourceId: annotations.resourceId,
       version: annotations.version,
@@ -10878,16 +10871,16 @@ Summary:`;
   /**
    * Check if resource exists in view storage
    */
-  static async resourceExists(resourceId7, kb) {
-    return await kb.views.exists(resourceId7);
+  static async resourceExists(resourceId10, kb) {
+    return kb.views.exists(resourceId10);
   }
   /**
    * Get a single annotation by ID
    * O(1) lookup using resource ID to access view storage
    */
-  static async getAnnotation(annotationId3, resourceId7, kb) {
-    const annotations = await this.getResourceAnnotations(resourceId7, kb);
-    return annotations.annotations.find((a) => a.id === annotationId3) || null;
+  static async getAnnotation(annotationId5, resourceId10, kb) {
+    const annotations = await this.getResourceAnnotations(resourceId10, kb);
+    return annotations.annotations.find((a) => a.id === annotationId5) || null;
   }
   /**
    * List annotations with optional filtering
@@ -10898,13 +10891,13 @@ Summary:`;
     if (!filters?.resourceId) {
       throw new Error("resourceId is required for annotation listing - cross-resource queries not supported in view storage");
     }
-    return await this.getAllAnnotations(filters.resourceId, kb);
+    return this.getAllAnnotations(filters.resourceId, kb);
   }
   /**
    * Get annotation context (selected text with surrounding context)
    */
-  static async getAnnotationContext(annotationId3, resourceId7, contextBefore, contextAfter, kb) {
-    const annotation = await this.getAnnotation(annotationId3, resourceId7, kb);
+  static async getAnnotationContext(annotationId5, resourceId10, contextBefore, contextAfter, kb) {
+    const annotation = await this.getAnnotation(annotationId5, resourceId10, kb);
     if (!annotation) {
       throw new Error("Annotation not found");
     }
@@ -10936,8 +10929,8 @@ Summary:`;
   /**
    * Generate AI summary of annotation in context
    */
-  static async generateAnnotationSummary(annotationId3, resourceId7, kb, inferenceClient) {
-    const annotation = await this.getAnnotation(annotationId3, resourceId7, kb);
+  static async generateAnnotationSummary(annotationId5, resourceId10, kb, inferenceClient) {
+    const annotation = await this.getAnnotation(annotationId5, resourceId10, kb);
     if (!annotation) {
       throw new Error("Annotation not found");
     }
@@ -11012,51 +11005,51 @@ Context after: "${context.after.substring(0, 200)}"
 
 Resource: ${resource.name}
 Entity types: ${entityTypes.join(", ")}`;
-    return await inferenceClient.generateText(summaryPrompt, 500, 0.5);
+    return inferenceClient.generateText(summaryPrompt, 500, 0.5);
   }
 };
 
 // src/graph-context.ts
-import { getResourceId as getResourceId2, getResourceEntityTypes as getResourceEntityTypes2 } from "@semiont/api-client";
+import { getResourceId as getResourceId2, getResourceEntityTypes as getResourceEntityTypes2 } from "@semiont/core";
 var GraphContext = class {
   /**
    * Get all resources referencing this resource (backlinks)
    * Requires graph traversal - must use graph database
    */
-  static async getBacklinks(resourceId7, kb) {
-    return await kb.graph.getResourceReferencedBy(resourceId7);
+  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 await kb.graph.findPath(fromResourceId, toResourceId, maxDepth);
+    return kb.graph.findPath(fromResourceId, toResourceId, maxDepth);
   }
   /**
    * Get resource connections (graph edges)
    * Requires graph traversal - must use graph database
    */
-  static async getResourceConnections(resourceId7, kb) {
-    return await kb.graph.getResourceConnections(resourceId7);
+  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 await kb.graph.searchResources(query, 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(resourceId7, maxRelated, kb) {
-    const mainDoc = await kb.graph.getResource(resourceId7);
+  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(resourceId7);
+    const connections = await kb.graph.getResourceConnections(resourceId10);
     const relatedDocs = connections.map((conn) => conn.targetResource).slice(0, maxRelated - 1);
     const nodes = [
       {
@@ -11073,7 +11066,7 @@ var GraphContext = class {
       }))
     ].filter((node) => node.id !== void 0);
     const edges = connections.slice(0, maxRelated - 1).map((conn) => ({
-      source: resourceId7,
+      source: resourceId10,
       target: getResourceId2(conn.targetResource),
       type: conn.relationshipType || "link",
       metadata: {}
@@ -11083,26 +11076,26 @@ var GraphContext = class {
 };
 
 // src/llm-context.ts
-import { getResourceEntityTypes as getResourceEntityTypes3, getResourceId as getResourceId3 } from "@semiont/api-client";
+import { getResourceEntityTypes as getResourceEntityTypes3, getResourceId as getResourceId3 } from "@semiont/core";
 import { resourceId as makeResourceId2 } from "@semiont/core";
 var LLMContext = class {
   /**
    * Get comprehensive LLM context for a resource
    * Includes: main resource, related resources, annotations, graph, content, summary, references
    */
-  static async getResourceContext(resourceId7, options, kb, inferenceClient) {
-    const mainDoc = await ResourceContext.getResourceMetadata(resourceId7, kb);
+  static async getResourceContext(resourceId10, options, kb, inferenceClient) {
+    const mainDoc = await ResourceContext.getResourceMetadata(resourceId10, kb);
     if (!mainDoc) {
       throw new Error("Resource not found");
     }
     const mainContent = options.includeContent ? await ResourceContext.getResourceContent(mainDoc, kb) : void 0;
     const graph = await GraphContext.buildGraphRepresentation(
-      resourceId7,
+      resourceId10,
       options.maxResources,
       kb
     );
     const relatedDocs = [];
-    const resourceIdStr = resourceId7.toString();
+    const resourceIdStr = resourceId10.toString();
     for (const node of graph.nodes) {
       if (node.id !== resourceIdStr) {
         const relatedDoc = await ResourceContext.getResourceMetadata(makeResourceId2(node.id), kb);
@@ -11124,7 +11117,7 @@ var LLMContext = class {
         })
       );
     }
-    const annotations = await AnnotationContext.getAllAnnotations(resourceId7, kb);
+    const annotations = await AnnotationContext.getAllAnnotations(resourceId10, kb);
     const summary = options.includeSummary && mainContent ? await generateResourceSummary(
       mainDoc.name,
       mainContent,
@@ -11163,7 +11156,9 @@ var Gatherer = class {
       (0, import_operators2.groupBy)((event) => event.resourceId),
       (0, import_operators2.mergeMap)(
         (group$) => group$.pipe(
-          (0, import_operators2.concatMap)((event) => (0, import_rxjs2.from)(this.handleAnnotationGather(event)))
+          (0, import_operators2.concatMap)(
+            (event) => (0, import_rxjs2.from)(withActorSpan("gatherer", "gather:requested", () => this.handleAnnotationGather(event)))
+          )
         )
       )
     );
@@ -11171,7 +11166,9 @@ var Gatherer = class {
       (0, import_operators2.groupBy)((event) => event.resourceId),
       (0, import_operators2.mergeMap)(
         (group$) => group$.pipe(
-          (0, import_operators2.concatMap)((event) => (0, import_rxjs2.from)(this.handleResourceGather(event)))
+          (0, import_operators2.concatMap)(
+            (event) => (0, import_rxjs2.from)(withActorSpan("gatherer", "gather:resource-requested", () => this.handleResourceGather(event)))
+          )
         )
       )
     );
@@ -11243,10 +11240,10 @@ var Gatherer = class {
       });
     }
   }
-  async generateAnnotationSummary(annotationId3, resourceId7) {
+  async generateAnnotationSummary(annotationId5, resourceId10) {
     return AnnotationContext.generateAnnotationSummary(
-      annotationId3,
-      resourceId7,
+      annotationId5,
+      resourceId10,
       this.kb,
       this.inferenceClient
     );
@@ -11264,7 +11261,8 @@ var Gatherer = class {
 var import_rxjs3 = __toESM(require_cjs(), 1);
 var import_operators3 = __toESM(require_operators(), 1);
 import { resourceId as resourceId2, errField as errField3 } from "@semiont/core";
-import { getResourceId as getResourceId4, getResourceEntityTypes as getResourceEntityTypes4 } from "@semiont/api-client";
+import { getResourceId as getResourceId4, getResourceEntityTypes as getResourceEntityTypes4 } from "@semiont/core";
+import { withActorSpan as withActorSpan2 } from "@semiont/observability";
 var Matcher = class {
   constructor(kb, eventBus, logger, inferenceClient, embeddingProvider) {
     this.kb = kb;
@@ -11279,7 +11277,9 @@ var Matcher = class {
     this.logger.info("Matcher actor initialized");
     const errorHandler = (err) => this.logger.error("Matcher pipeline error", { error: err });
     const search$ = this.eventBus.get("match:search-requested").pipe(
-      (0, import_operators3.concatMap)((event) => (0, import_rxjs3.from)(this.handleSearch(event)))
+      (0, import_operators3.concatMap)(
+        (event) => (0, import_rxjs3.from)(withActorSpan2("matcher", "match:search-requested", () => this.handleSearch(event)))
+      )
     );
     this.subscriptions.push(
       search$.subscribe({ error: errorHandler })
@@ -11582,7 +11582,8 @@ For each candidate, output a line with the number and score, like:
 var import_rxjs4 = __toESM(require_cjs(), 1);
 var import_operators4 = __toESM(require_operators(), 1);
 import { promises as fs } from "fs";
-import { errField as errField4, resourceId as resourceId3, userId as makeUserId, CREATION_METHODS, generateUuid } from "@semiont/core";
+import { annotationId, errField as errField4, resourceId as resourceId3, userId as makeUserId, CREATION_METHODS, generateUuid } from "@semiont/core";
+import { withActorSpan as withActorSpan3 } from "@semiont/observability";
 import { resolveStorageUri } from "@semiont/event-sourcing";
 var Stower = class {
   constructor(kb, eventBus, logger) {
@@ -11594,7 +11595,11 @@ var Stower = class {
   logger;
   async initialize() {
     this.logger.info("Stower actor initialized");
-    const pipe = (event, handler) => this.eventBus.get(event).pipe((0, import_operators4.concatMap)((e) => (0, import_rxjs4.from)(handler(e))));
+    const pipe = (event, handler) => this.eventBus.get(event).pipe(
+      (0, import_operators4.concatMap)(
+        (e) => (0, import_rxjs4.from)(withActorSpan3("stower", event, () => handler(e)))
+      )
+    );
     this.subscription = (0, import_rxjs4.merge)(
       pipe("yield:create", (e) => this.handleYieldCreate(e)),
       pipe("yield:update", (e) => this.handleYieldUpdate(e)),
@@ -11617,6 +11622,10 @@ var Stower = class {
   // Event handlers
   // ========================================================================
   async handleYieldCreate(event) {
+    if (!event._userId) {
+      throw new Error("yield:create missing _userId (gateway injection)");
+    }
+    const uid = makeUserId(event._userId);
     try {
       const rId = resourceId3(generateUuid());
       const stored = await this.kb.content.register(event.storageUri, event.contentChecksum, { noGit: event.noGit });
@@ -11624,11 +11633,14 @@ var Stower = class {
       const byteSize = event.byteSize;
       const validCreationMethods = Object.values(CREATION_METHODS);
       const validatedCreationMethod = event.creationMethod && validCreationMethods.includes(event.creationMethod) ? event.creationMethod : CREATION_METHODS.API;
-      const generatedFrom = event.generatedFrom?.resourceId && event.generatedFrom?.annotationId ? { resourceId: event.generatedFrom.resourceId, annotationId: event.generatedFrom.annotationId } : void 0;
+      const generatedFrom = event.generatedFrom?.resourceId && event.generatedFrom?.annotationId ? {
+        resourceId: resourceId3(event.generatedFrom.resourceId),
+        annotationId: annotationId(event.generatedFrom.annotationId)
+      } : void 0;
       await this.kb.eventStore.appendEvent({
         type: "yield:created",
         resourceId: rId,
-        userId: makeUserId(event.userId),
+        userId: uid,
         version: 1,
         payload: {
           name: event.name,
@@ -11669,7 +11681,7 @@ var Stower = class {
       if (generatedFrom) {
         this.eventBus.get("mark:update-body").next({
           annotationId: generatedFrom.annotationId,
-          userId: event.userId,
+          _userId: event._userId,
           resourceId: generatedFrom.resourceId,
           operations: [
             {
@@ -11696,12 +11708,15 @@ var Stower = class {
     }
   }
   async handleYieldUpdate(event) {
+    if (!event._userId) {
+      throw new Error("yield:update missing _userId (gateway injection)");
+    }
     try {
       await this.kb.content.register(event.storageUri, event.contentChecksum, { noGit: event.noGit });
       await this.kb.eventStore.appendEvent({
         type: "yield:updated",
         resourceId: resourceId3(event.resourceId),
-        userId: makeUserId(event.userId),
+        userId: makeUserId(event._userId),
         version: 1,
         payload: {
           contentChecksum: event.contentChecksum,
@@ -11730,12 +11745,15 @@ var Stower = class {
       });
       return;
     }
+    if (!event._userId) {
+      throw new Error("yield:mv missing _userId (gateway injection)");
+    }
     try {
       await this.kb.content.move(event.fromUri, event.toUri, { noGit: event.noGit });
       await this.kb.eventStore.appendEvent({
         type: "yield:moved",
         resourceId: rId,
-        userId: makeUserId(event.userId),
+        userId: makeUserId(event._userId),
         version: 1,
         payload: {
           fromUri: event.fromUri,
@@ -11752,13 +11770,16 @@ var Stower = class {
     }
   }
   async handleMarkCreate(event) {
+    if (!event._userId) {
+      throw new Error("mark:create missing _userId (gateway injection)");
+    }
     try {
       this.logger.debug("Stowing annotation", { annotationId: event.annotation.id });
       await this.kb.eventStore.appendEvent(
         {
           type: "mark:added",
           resourceId: resourceId3(event.resourceId),
-          userId: makeUserId(event.userId),
+          userId: makeUserId(event._userId),
           version: 1,
           payload: { annotation: event.annotation }
         },
@@ -11773,16 +11794,19 @@ var Stower = class {
     }
   }
   async handleMarkDelete(event) {
-    if (!event.userId || !event.resourceId) {
-      return;
+    if (!event._userId) {
+      throw new Error("mark:delete missing _userId (gateway injection)");
+    }
+    if (!event.resourceId) {
+      throw new Error("mark:delete missing resourceId");
     }
     try {
       await this.kb.eventStore.appendEvent({
         type: "mark:removed",
         resourceId: resourceId3(event.resourceId),
-        userId: makeUserId(event.userId),
+        userId: makeUserId(event._userId),
         version: 1,
-        payload: { annotationId: event.annotationId }
+        payload: { annotationId: annotationId(event.annotationId) }
       });
       this.eventBus.get("mark:delete-ok").next({ annotationId: event.annotationId });
     } catch (error) {
@@ -11793,12 +11817,15 @@ var Stower = class {
     }
   }
   async handleMarkUpdateBody(event) {
+    if (!event._userId) {
+      throw new Error("mark:update-body missing _userId (gateway injection)");
+    }
     try {
       await this.kb.eventStore.appendEvent(
         {
           type: "mark:body-updated",
           resourceId: resourceId3(event.resourceId),
-          userId: makeUserId(event.userId),
+          userId: makeUserId(event._userId),
           version: 1,
           payload: { annotationId: event.annotationId, operations: event.operations }
         },
@@ -11815,9 +11842,8 @@ var Stower = class {
     }
   }
   async handleMarkArchive(event) {
-    if (!event.userId) {
-      this.logger.warn("mark:archive missing userId \u2014 skipping (frontend-only event?)");
-      return;
+    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 });
@@ -11825,15 +11851,14 @@ var Stower = class {
     await this.kb.eventStore.appendEvent({
       type: "mark:archived",
       resourceId: resourceId3(event.resourceId),
-      userId: makeUserId(event.userId),
+      userId: makeUserId(event._userId),
       version: 1,
       payload: { reason: void 0 }
     });
   }
   async handleMarkUnarchive(event) {
-    if (!event.userId) {
-      this.logger.warn("mark:unarchive missing userId \u2014 skipping (frontend-only event?)");
-      return;
+    if (!event._userId) {
+      throw new Error("mark:unarchive missing _userId (gateway injection)");
     }
     if (event.storageUri) {
       const absPath = this.kb.content.resolveUri(event.storageUri);
@@ -11847,16 +11872,19 @@ var Stower = class {
     await this.kb.eventStore.appendEvent({
       type: "mark:unarchived",
       resourceId: resourceId3(event.resourceId),
-      userId: makeUserId(event.userId),
+      userId: makeUserId(event._userId),
       version: 1,
       payload: {}
     });
   }
   async handleAddEntityType(event) {
+    if (!event._userId) {
+      throw new Error("mark:add-entity-type missing _userId (gateway injection)");
+    }
     try {
       await this.kb.eventStore.appendEvent({
         type: "mark:entity-type-added",
-        userId: makeUserId(event.userId),
+        userId: makeUserId(event._userId),
         version: 1,
         payload: { entityType: event.tag }
       });
@@ -11868,32 +11896,39 @@ var Stower = class {
     }
   }
   async handleUpdateEntityTypes(event) {
+    if (!event._userId) {
+      throw new Error("mark:update-entity-types missing _userId (gateway injection)");
+    }
+    const uid = makeUserId(event._userId);
     const added = event.updatedEntityTypes.filter((et) => !event.currentEntityTypes.includes(et));
     const removed = event.currentEntityTypes.filter((et) => !event.updatedEntityTypes.includes(et));
-    for (const entityType of added) {
+    for (const entityType2 of added) {
       await this.kb.eventStore.appendEvent({
         type: "mark:entity-tag-added",
         resourceId: resourceId3(event.resourceId),
-        userId: makeUserId(event.userId),
+        userId: uid,
         version: 1,
-        payload: { entityType }
+        payload: { entityType: entityType2 }
       });
     }
-    for (const entityType of removed) {
+    for (const entityType2 of removed) {
       await this.kb.eventStore.appendEvent({
         type: "mark:entity-tag-removed",
         resourceId: resourceId3(event.resourceId),
-        userId: makeUserId(event.userId),
+        userId: uid,
         version: 1,
-        payload: { entityType }
+        payload: { entityType: entityType2 }
       });
     }
   }
   async handleJobStart(event) {
+    if (!event._userId) {
+      throw new Error("job:start missing _userId (gateway injection)");
+    }
     await this.kb.eventStore.appendEvent({
       type: "job:started",
       resourceId: resourceId3(event.resourceId),
-      userId: makeUserId(event.userId),
+      userId: makeUserId(event._userId),
       version: 1,
       payload: {
         jobId: event.jobId,
@@ -11903,10 +11938,13 @@ var Stower = class {
     });
   }
   async handleJobComplete(event) {
+    if (!event._userId) {
+      throw new Error("job:complete missing _userId (gateway injection)");
+    }
     await this.kb.eventStore.appendEvent({
       type: "job:completed",
       resourceId: resourceId3(event.resourceId),
-      userId: makeUserId(event.userId),
+      userId: makeUserId(event._userId),
       version: 1,
       payload: {
         jobId: event.jobId,
@@ -11917,10 +11955,13 @@ var Stower = class {
     });
   }
   async handleJobFail(event) {
+    if (!event._userId) {
+      throw new Error("job:fail missing _userId (gateway injection)");
+    }
     await this.kb.eventStore.appendEvent({
       type: "job:failed",
       resourceId: resourceId3(event.resourceId),
-      userId: makeUserId(event.userId),
+      userId: makeUserId(event._userId),
       version: 1,
       payload: {
         jobId: event.jobId,
@@ -11942,8 +11983,9 @@ var import_rxjs5 = __toESM(require_cjs(), 1);
 var import_operators5 = __toESM(require_operators(), 1);
 import { promises as fs3 } from "fs";
 import * as path2 from "path";
-import { resourceId as resourceId4, annotationId, errField as errField5 } from "@semiont/core";
-import { getExactText, getTargetSource as getTargetSource2, getTargetSelector as getTargetSelector2, getResourceEntityTypes as getResourceEntityTypes5, getBodySource as getBodySource2 } from "@semiont/api-client";
+import { resourceId as resourceId4, annotationId as annotationId2, errField as errField5 } from "@semiont/core";
+import { withActorSpan as withActorSpan4 } from "@semiont/observability";
+import { getExactText, getTargetSource as getTargetSource2, getTargetSelector as getTargetSelector2, getResourceEntityTypes as getResourceEntityTypes5, getBodySource as getBodySource2 } from "@semiont/core";
 import { EventQuery as EventQuery2 } from "@semiont/event-sourcing";
 import { getEntityTypes as getEntityTypes2 } from "@semiont/ontology";
 
@@ -11983,7 +12025,11 @@ var Browser = class {
   async initialize() {
     this.logger.info("Browser actor initialized");
     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)(handler(event))));
+    const pipe = (name, handler) => this.eventBus.get(name).pipe(
+      (0, import_operators5.mergeMap)(
+        (event) => (0, import_rxjs5.from)(withActorSpan4("browser", name, () => handler(event)))
+      )
+    );
     this.subscriptions.push(
       pipe("browse:resource-requested", (e) => this.handleBrowseResource(e)).subscribe({ error: errorHandler }),
       pipe("browse:resources-requested", (e) => this.handleBrowseResources(e)).subscribe({ error: errorHandler }),
@@ -12082,7 +12128,7 @@ var Browser = class {
   }
   async handleBrowseAnnotation(event) {
     try {
-      const annotation = await AnnotationContext.getAnnotation(annotationId(event.annotationId), resourceId4(event.resourceId), this.kb);
+      const annotation = await AnnotationContext.getAnnotation(annotationId2(event.annotationId), resourceId4(event.resourceId), this.kb);
       if (!annotation) {
         this.eventBus.get("browse:annotation-failed").next({
           correlationId: event.correlationId,
@@ -12146,7 +12192,7 @@ var Browser = class {
   }
   async handleBrowseAnnotationHistory(event) {
     try {
-      const annotation = await AnnotationContext.getAnnotation(annotationId(event.annotationId), resourceId4(event.resourceId), this.kb);
+      const annotation = await AnnotationContext.getAnnotation(annotationId2(event.annotationId), resourceId4(event.resourceId), this.kb);
       if (!annotation) {
         this.eventBus.get("browse:annotation-history-failed").next({
           correlationId: event.correlationId,
@@ -12198,7 +12244,7 @@ var Browser = class {
       const referencedBy = references.map((ref) => {
         const targetSource = getTargetSource2(ref.target);
         const targetSelector = getTargetSelector2(ref.target);
-        const doc = docMap.get(targetSource);
+        const doc = targetSource ? docMap.get(resourceId4(targetSource)) : void 0;
         return {
           id: ref.id,
           resourceName: doc?.name || "Untitled Resource",
@@ -12355,16 +12401,16 @@ function eventAnnotationId(event) {
       return null;
   }
 }
-async function readAnnotationFromView(kb, resourceId7, annotationId3) {
-  const allAnnotations = await AnnotationContext.getAllAnnotations(resourceId7, kb);
-  return allAnnotations.find((a) => a.id === annotationId3) ?? null;
+async function readAnnotationFromView(kb, resourceId10, annotationId5) {
+  const allAnnotations = await AnnotationContext.getAllAnnotations(resourceId10, kb);
+  return allAnnotations.find((a) => a.id === annotationId5) ?? null;
 }
 
 // src/clone-token-manager.ts
 var import_rxjs7 = __toESM(require_cjs(), 1);
 var import_operators7 = __toESM(require_operators(), 1);
 import { CREATION_METHODS as CREATION_METHODS2, cloneToken as makeCloneToken, resourceId as resourceId5, userId as makeUserId2 } from "@semiont/core";
-import { getPrimaryRepresentation as getPrimaryRepresentation3, getResourceEntityTypes as getResourceEntityTypes6 } from "@semiont/api-client";
+import { getPrimaryRepresentation as getPrimaryRepresentation3, getResourceEntityTypes as getResourceEntityTypes6 } from "@semiont/core";
 import { deriveStorageUri } from "@semiont/content";
 
 // src/resource-operations.ts
@@ -12375,7 +12421,7 @@ var ResourceOperations = class {
   /**
    * Create a new resource via EventBus → Stower
    */
-  static async createResource(input, userId2, eventBus) {
+  static async createResource(input, userId3, eventBus) {
     const result$ = (0, import_rxjs6.race)(
       eventBus.get("yield:create-ok").pipe(
         (0, import_operators6.take)(1),
@@ -12395,7 +12441,7 @@ var ResourceOperations = class {
       contentChecksum: input.contentChecksum,
       byteSize: input.byteSize,
       format: input.format,
-      userId: userId2,
+      _userId: userId3,
       language: input.language,
       entityTypes: input.entityTypes,
       creationMethod: input.creationMethod,
@@ -12410,26 +12456,6 @@ var ResourceOperations = class {
     }
     return makeResourceId3(outcome.result.resourceId);
   }
-  /**
-   * Update resource metadata via EventBus → Stower
-   */
-  static async updateResource(input, eventBus) {
-    if (input.updatedArchived !== void 0 && input.updatedArchived !== input.currentArchived) {
-      if (input.updatedArchived) {
-        eventBus.get("mark:archive").next({ userId: input.userId, resourceId: input.resourceId });
-      } else {
-        eventBus.get("mark:unarchive").next({ userId: input.userId, resourceId: input.resourceId });
-      }
-    }
-    if (input.updatedEntityTypes && input.currentEntityTypes) {
-      eventBus.get("mark:update-entity-types").next({
-        resourceId: input.resourceId,
-        userId: input.userId,
-        currentEntityTypes: input.currentEntityTypes,
-        updatedEntityTypes: input.updatedEntityTypes
-      });
-    }
-  }
 };
 
 // src/clone-token-manager.ts
@@ -12594,16 +12620,11 @@ var CloneTokenManager = class {
         makeUserId2(event.userId),
         this.eventBus
       );
-      if (event.archiveOriginal) {
-        ResourceOperations.updateResource(
-          {
-            resourceId: tokenData.resourceId,
-            userId: makeUserId2(event.userId),
-            currentArchived: sourceDoc.archived,
-            updatedArchived: true
-          },
-          this.eventBus
-        );
+      if (event.archiveOriginal && !sourceDoc.archived) {
+        this.eventBus.get("mark:archive").next({
+          _userId: event.userId,
+          resourceId: tokenData.resourceId
+        });
       }
       this.tokens.delete(token);
       this.eventBus.get("yield:clone-created").next({
@@ -12645,14 +12666,14 @@ async function bootstrapEntityTypes(eventBus, eventStore, logger) {
   }
   logger?.info("Bootstrapping missing entity types", { missing: missing.length, existing: existingTypes.size });
   const SYSTEM_USER_ID = userId("00000000-0000-0000-0000-000000000000");
-  for (const entityType of missing) {
-    logger?.debug("Adding entity type via EventBus", { entityType });
+  for (const entityType2 of missing) {
+    logger?.debug("Adding entity type via EventBus", { entityType: entityType2 });
     const result$ = (0, import_rxjs8.race)(
       eventBus.get("mark:entity-type-added").pipe((0, import_operators8.take)(1), (0, import_operators8.map)(() => ({ ok: true }))),
       eventBus.get("mark: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: ${entityType}`) })))
+      (0, import_rxjs8.timer)(1e4).pipe((0, import_operators8.map)(() => ({ ok: false, error: new Error(`Timeout adding entity type: ${entityType2}`) })))
     );
-    eventBus.get("mark:add-entity-type").next({ tag: entityType, userId: SYSTEM_USER_ID });
+    eventBus.get("mark:add-entity-type").next({ tag: entityType2, _userId: SYSTEM_USER_ID });
     const outcome = await (0, import_rxjs8.firstValueFrom)(result$);
     if (!outcome.ok) {
       throw outcome.error;
@@ -12672,15 +12693,281 @@ async function stopKnowledgeSystem(ks) {
   await ks.kb.graph.disconnect();
 }
 
+// src/handlers/annotation-assembly.ts
+import { resourceId as resourceId7, didToAgent as didToAgent2, assembleAnnotation } from "@semiont/core";
+function registerAnnotationAssemblyHandler(eventBus, parentLogger) {
+  const logger = parentLogger.child({ component: "annotation-assembly" });
+  const inflight = /* @__PURE__ */ new Map();
+  eventBus.get("mark:create-request").subscribe((command) => {
+    const { correlationId, resourceId: resId, request, _userId } = command;
+    const cid = correlationId;
+    try {
+      if (!_userId || typeof _userId !== "string") {
+        throw new Error("_userId is required (injected by bus gateway)");
+      }
+      if (!cid) {
+        throw new Error("correlationId is required on mark:create-request");
+      }
+      const agent = didToAgent2(_userId);
+      const { annotation } = assembleAnnotation(request, agent);
+      inflight.set(cid, { annotationId: annotation.id });
+      eventBus.get("mark:create").next({
+        correlationId: cid,
+        annotation,
+        _userId,
+        resourceId: resourceId7(resId)
+      });
+      logger.info("Annotation assembled, awaiting persistence", {
+        annotationId: annotation.id,
+        correlationId: cid
+      });
+    } catch (error) {
+      logger.warn("mark:create-request failed during assembly", {
+        correlationId: cid,
+        error: error.message
+      });
+      eventBus.get("mark:create-failed").next({
+        correlationId: cid,
+        message: error.message
+      });
+    }
+  });
+  eventBus.get("mark:added").subscribe((event) => {
+    const cid = event.metadata?.correlationId;
+    if (!cid) return;
+    const pending = inflight.get(cid);
+    if (!pending) return;
+    inflight.delete(cid);
+    eventBus.get("mark:create-ok").next({
+      correlationId: cid,
+      response: { annotationId: pending.annotationId }
+    });
+    logger.info("Annotation persisted", { annotationId: pending.annotationId, correlationId: cid });
+  });
+  eventBus.get("mark:create-failed").subscribe((event) => {
+    const cid = event.correlationId;
+    if (!cid || !inflight.has(cid)) return;
+    inflight.delete(cid);
+  });
+}
+
+// src/handlers/annotation-lookups.ts
+import { annotationId as makeAnnotationId3, resourceId as makeResourceId4 } from "@semiont/core";
+function registerAnnotationLookupHandlers(eventBus, kb, gatherer, parentLogger) {
+  const logger = parentLogger.child({ component: "annotation-lookups" });
+  eventBus.get("browse:annotation-context-requested").subscribe(async (command) => {
+    const { correlationId } = command;
+    const annId = command.annotationId;
+    const resId = command.resourceId;
+    const contextBefore = command.contextBefore ?? 100;
+    const contextAfter = command.contextAfter ?? 100;
+    try {
+      const response = await AnnotationContext.getAnnotationContext(
+        makeAnnotationId3(annId),
+        makeResourceId4(resId),
+        contextBefore,
+        contextAfter,
+        kb
+      );
+      eventBus.get("browse:annotation-context-result").next({
+        correlationId,
+        response
+      });
+    } catch (error) {
+      logger.warn("annotation-context failed", { correlationId, error: error.message });
+      eventBus.get("browse:annotation-context-failed").next({
+        correlationId,
+        message: error.message
+      });
+    }
+  });
+  eventBus.get("gather:summary-requested").subscribe(async (command) => {
+    const { correlationId } = command;
+    const annId = command.annotationId;
+    const resId = command.resourceId;
+    try {
+      const response = await gatherer.generateAnnotationSummary(
+        makeAnnotationId3(annId),
+        makeResourceId4(resId)
+      );
+      eventBus.get("gather:summary-result").next({
+        correlationId,
+        response
+      });
+    } catch (error) {
+      logger.warn("gather:summary failed", { correlationId, error: error.message });
+      eventBus.get("gather:summary-failed").next({
+        correlationId,
+        message: error.message
+      });
+    }
+  });
+}
+
+// src/handlers/bind-update-body.ts
+import { resourceId as resourceId8, annotationId as annotationId3 } from "@semiont/core";
+function registerBindUpdateBodyHandler(eventBus, parentLogger) {
+  const logger = parentLogger.child({ component: "bind-update-body" });
+  const inflight = /* @__PURE__ */ new Set();
+  eventBus.get("bind:update-body").subscribe((command) => {
+    const { correlationId, annotationId: annId, resourceId: resId, operations, _userId } = command;
+    const cid = correlationId;
+    try {
+      if (!_userId || typeof _userId !== "string") {
+        throw new Error("_userId is required (injected by bus gateway)");
+      }
+      if (!cid) {
+        throw new Error("correlationId is required on bind:update-body");
+      }
+      inflight.add(cid);
+      eventBus.get("mark:update-body").next({
+        correlationId: cid,
+        annotationId: annotationId3(annId),
+        _userId,
+        resourceId: resourceId8(resId),
+        operations
+      });
+      logger.info("Bind update-body forwarded to mark:update-body, awaiting persistence", {
+        annotationId: annId,
+        correlationId: cid
+      });
+    } catch (error) {
+      logger.warn("bind:update-body failed before forwarding", {
+        correlationId: cid,
+        error: error.message
+      });
+      eventBus.get("bind:body-update-failed").next({
+        correlationId: cid,
+        message: error.message
+      });
+    }
+  });
+  eventBus.get("mark:body-updated").subscribe((event) => {
+    const cid = event.metadata?.correlationId;
+    if (!cid || !inflight.has(cid)) return;
+    inflight.delete(cid);
+    const annId = event.payload?.annotationId;
+    eventBus.get("bind:body-updated").next({
+      correlationId: cid,
+      annotationId: annId
+    });
+    logger.info("Bind body-updated confirmed", { annotationId: annId, correlationId: cid });
+  });
+  eventBus.get("mark:body-update-failed").subscribe((event) => {
+    const cid = event.correlationId;
+    if (!cid || !inflight.has(cid)) return;
+    inflight.delete(cid);
+    const message = event.message ?? "Unknown error";
+    eventBus.get("bind:body-update-failed").next({
+      correlationId: cid,
+      message
+    });
+    logger.warn("Bind body-update failed after forwarding", { correlationId: cid, message });
+  });
+}
+
+// src/handlers/job-commands.ts
+import { generateUuid as generateUuid2, jobId, userId as userId2, resourceId as resourceId9, entityType } from "@semiont/core";
+function parseDidUser(did) {
+  const parts = did.split(":");
+  const usersIdx = parts.indexOf("users");
+  const domain = parts.slice(2, usersIdx).join(":");
+  const email = decodeURIComponent(parts.slice(usersIdx + 1).join(":"));
+  return { userId: did, email, domain };
+}
+function registerJobCommandHandlers(eventBus, jobQueue, parentLogger) {
+  const logger = parentLogger.child({ component: "job-commands" });
+  eventBus.get("job:create").subscribe(async (command) => {
+    const { correlationId, jobType, resourceId: resId, params, _userId } = command;
+    try {
+      if (!_userId || typeof _userId !== "string") {
+        throw new Error("_userId is required (injected by bus gateway)");
+      }
+      const user = parseDidUser(_userId);
+      const job = {
+        status: "pending",
+        metadata: {
+          id: jobId(`job-${generateUuid2()}`),
+          type: jobType,
+          userId: userId2(_userId),
+          userName: user.email,
+          userEmail: user.email,
+          userDomain: user.domain,
+          created: (/* @__PURE__ */ new Date()).toISOString(),
+          retryCount: 0,
+          maxRetries: jobType === "generation" ? 3 : 1
+        },
+        params: {
+          resourceId: resourceId9(resId),
+          ...params
+        }
+      };
+      const jobParams = job.params;
+      if (jobType === "reference-annotation" && jobParams.entityTypes) {
+        jobParams.entityTypes = jobParams.entityTypes.map((et) => entityType(et));
+      }
+      await jobQueue.createJob(job);
+      logger.info("Job created via bus", { jobId: job.metadata.id, jobType, correlationId });
+      eventBus.get("job:created").next({
+        correlationId,
+        response: { jobId: job.metadata.id }
+      });
+    } catch (error) {
+      logger.error("job:create failed", { correlationId, error: error.message });
+      eventBus.get("job:create-failed").next({
+        correlationId,
+        message: error.message
+      });
+    }
+  });
+  eventBus.get("job:claim").subscribe(async (command) => {
+    const { correlationId, jobId: jid } = command;
+    try {
+      const job = await jobQueue.getJob(jobId(jid));
+      if (!job) {
+        throw new Error("Job not found");
+      }
+      if (job.status !== "pending") {
+        throw new Error("Job already claimed");
+      }
+      const runningJob = {
+        ...job,
+        status: "running",
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        progress: {}
+      };
+      await jobQueue.updateJob(runningJob, "pending");
+      eventBus.get("job:claimed").next({
+        correlationId,
+        response: runningJob
+      });
+    } catch (error) {
+      eventBus.get("job:claim-failed").next({
+        correlationId,
+        message: error.message
+      });
+    }
+  });
+}
+
+// src/handlers/index.ts
+function registerBusHandlers(eventBus, knowledgeSystem, jobQueue, logger) {
+  registerAnnotationAssemblyHandler(eventBus, logger);
+  registerAnnotationLookupHandlers(eventBus, knowledgeSystem.kb, knowledgeSystem.gatherer, logger);
+  registerBindUpdateBodyHandler(eventBus, logger);
+  registerJobCommandHandlers(eventBus, jobQueue, logger);
+}
+
 // src/service.ts
 async function createJobQueue(project, eventBus, logger) {
   const jobQueueLogger = logger.child({ component: "job-queue" });
   const jobQueue = new FsJobQueue(project, jobQueueLogger, eventBus);
   await jobQueue.initialize();
+  registerJobQueueProvider(() => jobQueue.getStats());
   const jobStatusSubscription = eventBus.get("job:status-requested").pipe(
     (0, import_operators9.mergeMap)((event) => (0, import_rxjs9.from)((async () => {
       try {
-        const job = await jobQueue.getJob(jobId(event.jobId));
+        const job = await jobQueue.getJob(jobId2(event.jobId));
         if (!job) {
           eventBus.get("job:status-failed").next({ correlationId: event.correlationId, message: "Job not found" });
           return;
@@ -12739,10 +13026,10 @@ async function createKnowledgeSystemFromConfig(project, config, eventBus, logger
     vectorStore,
     skipRebuild
   });
-  eventStore.setEnrichEvent(async (event, resourceId7) => {
+  eventStore.setEnrichEvent(async (event, resourceId10) => {
     const annId = eventAnnotationId(event);
     if (annId === null) return event;
-    const annotation = await readAnnotationFromView(kb, resourceId7, annId);
+    const annotation = await readAnnotationFromView(kb, resourceId10, annId);
     if (annotation === null) return event;
     return { ...event, annotation };
   });
@@ -12779,6 +13066,7 @@ async function startMakeMeaning(project, config, eventBus, logger, options) {
   const skipRebuild = options?.skipRebuild ?? process.env.SEMIONT_SKIP_REBUILD === "true";
   const { jobQueue, jobStatusSubscription } = await createJobQueue(project, eventBus, logger);
   const knowledgeSystem = await createKnowledgeSystemFromConfig(project, config, eventBus, logger, skipRebuild);
+  registerBusHandlers(eventBus, knowledgeSystem, jobQueue, logger);
   return {
     knowledgeSystem,
     jobQueue,
@@ -12791,6 +13079,212 @@ async function startMakeMeaning(project, config, eventBus, logger, options) {
   };
 }
 
+// src/local-transport.ts
+var import_rxjs10 = __toESM(require_cjs(), 1);
+import { baseUrl as makeBaseUrl, busLog } from "@semiont/core";
+import { SpanKind, recordBusEmit, withSpan } from "@semiont/observability";
+import {
+  BRIDGED_CHANNELS
+} from "@semiont/core";
+var NOT_SUPPORTED = (method) => new Error(`LocalTransport does not support ${method}() \u2014 local mode runs as a single host-process identity`);
+var LocalTransport = class {
+  baseUrl;
+  state$;
+  bus;
+  userId;
+  bridges = [];
+  bridgeSubs = [];
+  disposed = false;
+  constructor(cfg) {
+    this.bus = cfg.eventBus;
+    this.userId = cfg.userId;
+    this.baseUrl = cfg.baseUrl ?? makeBaseUrl("local://in-process");
+    this.state$ = new import_rxjs10.BehaviorSubject("open");
+  }
+  // ── Bus primitives ──────────────────────────────────────────────────────
+  async emit(channel, payload, resourceScope) {
+    busLog("EMIT", channel, payload, resourceScope);
+    recordBusEmit(channel, resourceScope);
+    await withSpan(
+      `bus.emit:${channel}`,
+      () => {
+        const stamped = { ...payload, _userId: this.userId };
+        const target = resourceScope === void 0 ? this.bus.get(channel) : this.bus.scope(resourceScope).get(channel);
+        target.next(stamped);
+      },
+      {
+        kind: SpanKind.PRODUCER,
+        attrs: {
+          "bus.channel": channel,
+          ...resourceScope ? { "bus.scope": resourceScope } : {}
+        }
+      }
+    );
+  }
+  on(channel, handler) {
+    const sub = this.bus.get(channel).subscribe(handler);
+    return () => sub.unsubscribe();
+  }
+  stream(channel) {
+    return this.bus.get(channel);
+  }
+  subscribeToResource(_resourceId) {
+    return () => {
+    };
+  }
+  bridgeInto(bus) {
+    if (this.bridges.includes(bus)) return;
+    this.bridges.push(bus);
+    for (const channel of BRIDGED_CHANNELS) {
+      const upstream = this.bus.get(channel);
+      this.bridgeSubs.push(
+        upstream.subscribe((payload) => {
+          busLog("RECV", channel, payload);
+          void withSpan(
+            `bus.recv:${channel}`,
+            () => {
+              bus.get(channel).next(payload);
+            },
+            { kind: SpanKind.CONSUMER, attrs: { "bus.channel": channel } }
+          );
+        })
+      );
+    }
+  }
+  // ── Auth (not supported) ────────────────────────────────────────────────
+  async authenticatePassword(_email, _password) {
+    throw NOT_SUPPORTED("authenticatePassword");
+  }
+  async authenticateGoogle(_credential) {
+    throw NOT_SUPPORTED("authenticateGoogle");
+  }
+  async refreshAccessToken(_token) {
+    throw NOT_SUPPORTED("refreshAccessToken");
+  }
+  async logout() {
+  }
+  async acceptTerms() {
+  }
+  async getCurrentUser() {
+    return {
+      did: this.userId,
+      email: "",
+      isAdmin: false,
+      isModerator: false,
+      termsAcceptedAt: null
+    };
+  }
+  async generateMcpToken() {
+    throw NOT_SUPPORTED("generateMcpToken");
+  }
+  async getMediaToken(_resourceId) {
+    throw NOT_SUPPORTED("getMediaToken");
+  }
+  // ── Admin (not supported) ───────────────────────────────────────────────
+  async listUsers() {
+    throw NOT_SUPPORTED("listUsers");
+  }
+  async getUserStats() {
+    throw NOT_SUPPORTED("getUserStats");
+  }
+  async updateUser(_id, _data) {
+    throw NOT_SUPPORTED("updateUser");
+  }
+  async getOAuthConfig() {
+    throw NOT_SUPPORTED("getOAuthConfig");
+  }
+  // ── Exchange (not supported) ────────────────────────────────────────────
+  async backupKnowledgeBase() {
+    throw NOT_SUPPORTED("backupKnowledgeBase");
+  }
+  async restoreKnowledgeBase(_file, _onProgress) {
+    throw NOT_SUPPORTED("restoreKnowledgeBase");
+  }
+  async exportKnowledgeBase(_params) {
+    throw NOT_SUPPORTED("exportKnowledgeBase");
+  }
+  async importKnowledgeBase(_file, _onProgress) {
+    throw NOT_SUPPORTED("importKnowledgeBase");
+  }
+  // ── System ──────────────────────────────────────────────────────────────
+  async healthCheck() {
+    return { status: "ok" };
+  }
+  async getStatus() {
+    return { status: "ok" };
+  }
+  // ── Lifecycle ───────────────────────────────────────────────────────────
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    for (const sub of this.bridgeSubs) sub.unsubscribe();
+    this.bridgeSubs.length = 0;
+    this.bridges.length = 0;
+    this.state$.next("closed");
+    this.state$.complete();
+  }
+};
+
+// src/local-content-transport.ts
+import { busLog as busLog2 } from "@semiont/core";
+import { SpanKind as SpanKind2, withSpan as withSpan2 } from "@semiont/observability";
+function primaryRepresentation(reps) {
+  if (!reps) return void 0;
+  return Array.isArray(reps) ? reps[0] : reps;
+}
+var LocalContentTransport = class {
+  constructor(ks) {
+    this.ks = ks;
+  }
+  async putBinary(_request, _options) {
+    throw new Error(
+      "LocalContentTransport does not support putBinary() \u2014 create resources via bus emits (mark/yield namespaces) in local mode"
+    );
+  }
+  async getBinary(resourceId10, options) {
+    busLog2("GET", "content", { resourceId: resourceId10, accept: options?.accept });
+    return withSpan2(
+      "content.get",
+      () => this.loadBinary(resourceId10),
+      { kind: SpanKind2.INTERNAL, attrs: { "resource.id": resourceId10 } }
+    );
+  }
+  async getBinaryStream(resourceId10, options) {
+    busLog2("GET", "content", { resourceId: resourceId10, accept: options?.accept, stream: true });
+    return withSpan2(
+      "content.get",
+      async () => {
+        const { data, contentType } = await this.loadBinary(resourceId10);
+        const bytes = new Uint8Array(data);
+        const stream = new ReadableStream({
+          start(controller) {
+            controller.enqueue(bytes);
+            controller.close();
+          }
+        });
+        return { stream, contentType };
+      },
+      {
+        kind: SpanKind2.INTERNAL,
+        attrs: { "resource.id": resourceId10, "content.stream": true }
+      }
+    );
+  }
+  async loadBinary(resourceId10) {
+    const view = await this.ks.kb.views.get(resourceId10);
+    if (!view) throw new Error(`Resource not found: ${resourceId10}`);
+    const rep = primaryRepresentation(view.resource.representations);
+    if (!rep?.storageUri) {
+      throw new Error(`Resource ${resourceId10} has no representation with a storageUri`);
+    }
+    const buf = await this.ks.kb.content.retrieve(rep.storageUri);
+    const data = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+    return { data, contentType: rep.mediaType };
+  }
+  dispose() {
+  }
+};
+
 // src/exchange/backup-exporter.ts
 import { getExtensionForMimeType } from "@semiont/content";
 
@@ -12982,7 +13476,7 @@ function collectContentRefs(streamData) {
 }
 
 // src/exchange/replay.ts
-var import_rxjs10 = __toESM(require_cjs(), 1);
+var import_rxjs11 = __toESM(require_cjs(), 1);
 var import_operators10 = __toESM(require_operators(), 1);
 import { deriveStorageUri as deriveStorageUri2 } from "@semiont/content";
 var REPLAY_TIMEOUT_MS = 3e4;
@@ -13048,20 +13542,20 @@ async function replayEvent(event, eventBus, resolveBlob, contentStore, stats, lo
   }
 }
 async function replayEntityTypeAdded(event, eventBus, logger) {
-  const result$ = (0, import_rxjs10.race)(
+  const result$ = (0, import_rxjs11.race)(
     eventBus.get("mark:entity-type-added").pipe((0, import_operators10.map)(() => "ok")),
     eventBus.get("mark:entity-type-add-failed").pipe((0, import_operators10.map)((e) => {
       throw new Error(e.message);
     })),
-    (0, import_rxjs10.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators10.map)(() => {
+    (0, import_rxjs11.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators10.map)(() => {
       throw new Error("Timeout waiting for mark:entity-type-added");
     }))
   );
   eventBus.get("mark:add-entity-type").next({
     tag: event.payload.entityType,
-    userId: event.userId
+    _userId: event.userId
   });
-  await (0, import_rxjs10.firstValueFrom)(result$);
+  await (0, import_rxjs11.firstValueFrom)(result$);
   logger?.debug("Replayed entitytype.added", { entityType: event.payload.entityType });
 }
 async function replayResourceCreated(event, eventBus, resolveBlob, contentStore, logger) {
@@ -13072,12 +13566,12 @@ async function replayResourceCreated(event, eventBus, resolveBlob, contentStore,
   }
   const resolvedUri = payload.storageUri || deriveStorageUri2(payload.name, payload.format);
   const stored = await contentStore.store(blob, resolvedUri);
-  const result$ = (0, import_rxjs10.race)(
+  const result$ = (0, import_rxjs11.race)(
     eventBus.get("yield:create-ok").pipe((0, import_operators10.map)((r) => r)),
     eventBus.get("yield:create-failed").pipe((0, import_operators10.map)((e) => {
       throw new Error(e.message);
     })),
-    (0, import_rxjs10.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators10.map)(() => {
+    (0, import_rxjs11.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators10.map)(() => {
       throw new Error("Timeout waiting for yield:create-ok");
     }))
   );
@@ -13087,7 +13581,7 @@ async function replayResourceCreated(event, eventBus, resolveBlob, contentStore,
     contentChecksum: stored.checksum,
     byteSize: stored.byteSize,
     format: payload.format,
-    userId: event.userId,
+    _userId: event.userId,
     language: payload.language,
     entityTypes: payload.entityTypes,
     creationMethod: payload.creationMethod,
@@ -13095,97 +13589,97 @@ async function replayResourceCreated(event, eventBus, resolveBlob, contentStore,
     generatedFrom: payload.generatedFrom,
     generationPrompt: payload.generationPrompt
   });
-  await (0, import_rxjs10.firstValueFrom)(result$);
+  await (0, import_rxjs11.firstValueFrom)(result$);
   logger?.debug("Replayed resource.created", { name: payload.name });
 }
 async function replayAnnotationAdded(event, eventBus, logger) {
-  const result$ = (0, import_rxjs10.race)(
+  const result$ = (0, import_rxjs11.race)(
     eventBus.get("mark:create-ok").pipe((0, import_operators10.map)(() => "ok")),
     eventBus.get("mark:create-failed").pipe((0, import_operators10.map)((e) => {
       throw new Error(e.message);
     })),
-    (0, import_rxjs10.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators10.map)(() => {
+    (0, import_rxjs11.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators10.map)(() => {
       throw new Error("Timeout waiting for mark:create-ok");
     }))
   );
   eventBus.get("mark:create").next({
     annotation: event.payload.annotation,
-    userId: event.userId,
+    _userId: event.userId,
     resourceId: event.resourceId
   });
-  await (0, import_rxjs10.firstValueFrom)(result$);
+  await (0, import_rxjs11.firstValueFrom)(result$);
   logger?.debug("Replayed annotation.added", { annotationId: event.payload.annotation.id });
 }
 async function replayAnnotationBodyUpdated(event, eventBus, logger) {
-  const result$ = (0, import_rxjs10.race)(
+  const result$ = (0, import_rxjs11.race)(
     eventBus.get("mark:body-updated").pipe((0, import_operators10.map)(() => "ok")),
     eventBus.get("mark:body-update-failed").pipe((0, import_operators10.map)((e) => {
       throw new Error(e.message);
     })),
-    (0, import_rxjs10.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators10.map)(() => {
+    (0, import_rxjs11.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators10.map)(() => {
       throw new Error("Timeout waiting for mark:body-updated");
     }))
   );
   eventBus.get("mark:update-body").next({
     annotationId: event.payload.annotationId,
-    userId: event.userId,
+    _userId: event.userId,
     resourceId: event.resourceId,
     operations: event.payload.operations
   });
-  await (0, import_rxjs10.firstValueFrom)(result$);
+  await (0, import_rxjs11.firstValueFrom)(result$);
   logger?.debug("Replayed annotation.body.updated", { annotationId: event.payload.annotationId });
 }
 async function replayAnnotationRemoved(event, eventBus, logger) {
-  const result$ = (0, import_rxjs10.race)(
+  const result$ = (0, import_rxjs11.race)(
     eventBus.get("mark:delete-ok").pipe((0, import_operators10.map)(() => "ok")),
     eventBus.get("mark:delete-failed").pipe((0, import_operators10.map)((e) => {
       throw new Error(e.message);
     })),
-    (0, import_rxjs10.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators10.map)(() => {
+    (0, import_rxjs11.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators10.map)(() => {
       throw new Error("Timeout waiting for mark:delete-ok");
     }))
   );
   eventBus.get("mark:delete").next({
     annotationId: event.payload.annotationId,
-    userId: event.userId,
+    _userId: event.userId,
     resourceId: event.resourceId
   });
-  await (0, import_rxjs10.firstValueFrom)(result$);
+  await (0, import_rxjs11.firstValueFrom)(result$);
   logger?.debug("Replayed annotation.removed", { annotationId: event.payload.annotationId });
 }
 async function replayResourceArchived(event, eventBus, logger) {
   eventBus.get("mark:archive").next({
-    userId: event.userId,
+    _userId: event.userId,
     resourceId: event.resourceId
   });
   logger?.debug("Replayed resource.archived", { resourceId: event.resourceId });
 }
 async function replayResourceUnarchived(event, eventBus, logger) {
   eventBus.get("mark:unarchive").next({
-    userId: event.userId,
+    _userId: event.userId,
     resourceId: event.resourceId
   });
   logger?.debug("Replayed resource.unarchived", { resourceId: event.resourceId });
 }
 async function replayEntityTagChange(event, eventBus, logger) {
-  const resourceId7 = event.resourceId;
-  const entityType = event.payload.entityType;
+  const resourceId10 = event.resourceId;
+  const entityType2 = event.payload.entityType;
   if (event.type === "mark:entity-tag-added") {
     eventBus.get("mark:update-entity-types").next({
-      resourceId: resourceId7,
-      userId: event.userId,
+      resourceId: resourceId10,
+      _userId: event.userId,
       currentEntityTypes: [],
-      updatedEntityTypes: [entityType]
+      updatedEntityTypes: [entityType2]
     });
   } else {
     eventBus.get("mark:update-entity-types").next({
-      resourceId: resourceId7,
-      userId: event.userId,
-      currentEntityTypes: [entityType],
+      resourceId: resourceId10,
+      _userId: event.userId,
+      currentEntityTypes: [entityType2],
       updatedEntityTypes: []
     });
   }
-  logger?.debug("Replayed entity tag change", { type: event.type, entityType });
+  logger?.debug("Replayed entity tag change", { type: event.type, entityType: entityType2 });
 }
 
 // src/exchange/backup-importer.ts
@@ -13359,10 +13853,10 @@ async function exportLinkedData(options, output) {
       data: Buffer.from(JSON.stringify(manifest, null, 2), "utf8")
     };
     for (const view of resourceViews) {
-      const resourceId7 = view.resource["@id"];
+      const resourceId10 = view.resource["@id"];
       const jsonld = buildResourceJsonLd(view.resource, view.annotations.annotations, sourceUrl);
       yield {
-        name: `.semiont/resources/${resourceId7}.jsonld`,
+        name: `.semiont/resources/${resourceId10}.jsonld`,
         data: Buffer.from(JSON.stringify(jsonld, null, 2), "utf8")
       };
     }
@@ -13379,8 +13873,8 @@ async function exportLinkedData(options, output) {
   return manifest;
 }
 function buildResourceJsonLd(resource, annotations, sourceUrl) {
-  const resourceId7 = resource["@id"];
-  const resourceUri = resourceId7.startsWith("http") ? resourceId7 : `${sourceUrl}/resources/${resourceId7}`;
+  const resourceId10 = resource["@id"];
+  const resourceUri = resourceId10.startsWith("http") ? resourceId10 : `${sourceUrl}/resources/${resourceId10}`;
   const doc = {
     "@context": SEMIONT_CONTEXT,
     "@id": resourceUri,
@@ -13440,9 +13934,9 @@ function collectContentRefsFromResource(resource, refs) {
 }
 
 // src/exchange/linked-data-importer.ts
-var import_rxjs11 = __toESM(require_cjs(), 1);
+var import_rxjs12 = __toESM(require_cjs(), 1);
 var import_operators11 = __toESM(require_operators(), 1);
-import { resourceId as makeResourceId4 } from "@semiont/core";
+import { annotationId as annotationIdFactory, resourceId as makeResourceId5 } from "@semiont/core";
 import { deriveStorageUri as deriveStorageUri3 } from "@semiont/content";
 var IMPORT_TIMEOUT_MS = 3e4;
 function stripUriToId(uri) {
@@ -13453,7 +13947,7 @@ function stripUriToId(uri) {
 function dehydrateAnnotation(annotation) {
   const dehydrated = { ...annotation };
   if (dehydrated.id) {
-    dehydrated.id = stripUriToId(dehydrated.id);
+    dehydrated.id = annotationIdFactory(stripUriToId(dehydrated.id));
   }
   if (typeof dehydrated.target === "string") {
     dehydrated.target = stripUriToId(dehydrated.target);
@@ -13497,7 +13991,7 @@ function buildBlobResolver2(entries) {
   };
 }
 async function importLinkedData(archive, options) {
-  const { eventBus, contentStore, userId: userId2, logger } = options;
+  const { eventBus, contentStore, userId: userId3, logger } = options;
   const entries = /* @__PURE__ */ new Map();
   for await (const entry of readTarGz(archive)) {
     entries.set(entry.name, entry.data);
@@ -13519,8 +14013,8 @@ async function importLinkedData(archive, options) {
   });
   const resolveBlob = buildBlobResolver2(entries);
   let entityTypesAdded = 0;
-  for (const entityType of manifest["semiont:entityTypes"]) {
-    await addEntityType(entityType, userId2, eventBus, logger);
+  for (const entityType2 of manifest["semiont:entityTypes"]) {
+    await addEntityType(entityType2, userId3, eventBus, logger);
     entityTypesAdded++;
   }
   const resourceEntries = [...entries.keys()].filter((name) => name.startsWith(".semiont/resources/") && name.endsWith(".jsonld")).sort();
@@ -13528,7 +14022,7 @@ async function importLinkedData(archive, options) {
   let annotationsCreated = 0;
   for (const entryName of resourceEntries) {
     const resourceDoc = JSON.parse(entries.get(entryName).toString("utf8"));
-    const result = await importResource(resourceDoc, userId2, eventBus, contentStore, resolveBlob, logger);
+    const result = await importResource(resourceDoc, userId3, eventBus, contentStore, resolveBlob, logger);
     resourcesCreated++;
     annotationsCreated += result.annotationsCreated;
   }
@@ -13544,24 +14038,24 @@ async function importLinkedData(archive, options) {
     entityTypesAdded
   };
 }
-async function addEntityType(entityType, userId2, eventBus, logger) {
-  const result$ = (0, import_rxjs11.race)(
+async function addEntityType(entityType2, userId3, eventBus, logger) {
+  const result$ = (0, import_rxjs12.race)(
     eventBus.get("mark:entity-type-added").pipe((0, import_operators11.map)(() => "ok")),
     eventBus.get("mark:entity-type-add-failed").pipe((0, import_operators11.map)((e) => {
       throw new Error(e.message);
     })),
-    (0, import_rxjs11.timer)(IMPORT_TIMEOUT_MS).pipe((0, import_operators11.map)(() => {
+    (0, import_rxjs12.timer)(IMPORT_TIMEOUT_MS).pipe((0, import_operators11.map)(() => {
       throw new Error("Timeout waiting for mark:entity-type-added");
     }))
   );
   eventBus.get("mark:add-entity-type").next({
-    tag: entityType,
-    userId: userId2
+    tag: entityType2,
+    _userId: userId3
   });
-  await (0, import_rxjs11.firstValueFrom)(result$);
-  logger?.debug("Added entity type", { entityType });
+  await (0, import_rxjs12.firstValueFrom)(result$);
+  logger?.debug("Added entity type", { entityType: entityType2 });
 }
-async function importResource(doc, userId2, eventBus, contentStore, resolveBlob, logger) {
+async function importResource(doc, userId3, eventBus, contentStore, resolveBlob, logger) {
   const name = doc["name"];
   const representations = doc["representations"];
   const annotations = doc["annotations"];
@@ -13585,12 +14079,12 @@ async function importResource(doc, userId2, eventBus, contentStore, resolveBlob,
   }
   const resolvedUri = deriveStorageUri3(name, format);
   const stored = await contentStore.store(blob, resolvedUri);
-  const createResult$ = (0, import_rxjs11.race)(
+  const createResult$ = (0, import_rxjs12.race)(
     eventBus.get("yield:create-ok").pipe((0, import_operators11.map)((r) => r)),
     eventBus.get("yield:create-failed").pipe((0, import_operators11.map)((e) => {
       throw new Error(e.message);
     })),
-    (0, import_rxjs11.timer)(IMPORT_TIMEOUT_MS).pipe((0, import_operators11.map)(() => {
+    (0, import_rxjs12.timer)(IMPORT_TIMEOUT_MS).pipe((0, import_operators11.map)(() => {
       throw new Error("Timeout waiting for yield:create-ok");
     }))
   );
@@ -13600,60 +14094,60 @@ async function importResource(doc, userId2, eventBus, contentStore, resolveBlob,
     contentChecksum: stored.checksum,
     byteSize: stored.byteSize,
     format,
-    userId: userId2,
+    _userId: userId3,
     language,
     entityTypes: entityTypes ?? [],
     creationMethod
   });
-  const created = await (0, import_rxjs11.firstValueFrom)(createResult$);
-  const resourceId7 = makeResourceId4(created.resourceId);
-  logger?.debug("Created resource from JSON-LD", { name, resourceId: resourceId7 });
+  const created = await (0, import_rxjs12.firstValueFrom)(createResult$);
+  const resourceId10 = makeResourceId5(created.resourceId);
+  logger?.debug("Created resource from JSON-LD", { name, resourceId: resourceId10 });
   let annotationsCreated = 0;
   if (annotations && annotations.length > 0) {
     for (const annotation of annotations) {
-      await createAnnotation(annotation, resourceId7, userId2, eventBus, logger);
+      await createAnnotation(annotation, resourceId10, userId3, eventBus, logger);
       annotationsCreated++;
     }
   }
   return { annotationsCreated };
 }
-async function createAnnotation(annotation, resourceId7, userId2, eventBus, logger) {
-  const result$ = (0, import_rxjs11.race)(
+async function createAnnotation(annotation, resourceId10, userId3, eventBus, logger) {
+  const result$ = (0, import_rxjs12.race)(
     eventBus.get("mark:create-ok").pipe((0, import_operators11.map)(() => "ok")),
     eventBus.get("mark:create-failed").pipe((0, import_operators11.map)((e) => {
       throw new Error(e.message);
     })),
-    (0, import_rxjs11.timer)(IMPORT_TIMEOUT_MS).pipe((0, import_operators11.map)(() => {
+    (0, import_rxjs12.timer)(IMPORT_TIMEOUT_MS).pipe((0, import_operators11.map)(() => {
       throw new Error("Timeout waiting for mark:create-ok");
     }))
   );
   eventBus.get("mark:create").next({
     annotation: dehydrateAnnotation(annotation),
-    userId: userId2,
-    resourceId: resourceId7
+    _userId: userId3,
+    resourceId: resourceId10
   });
-  await (0, import_rxjs11.firstValueFrom)(result$);
+  await (0, import_rxjs12.firstValueFrom)(result$);
   logger?.debug("Created annotation", { annotationId: annotation.id });
 }
 
 // src/annotation-assembly.ts
 import {
-  assembleAnnotation,
+  assembleAnnotation as assembleAnnotation2,
   applyBodyOperations
 } from "@semiont/core";
 
 // src/annotation-operations.ts
-import { annotationId as annotationId2, resourceId as makeResourceId5, assembleAnnotation as assembleAnnotation2, applyBodyOperations as applyBodyOperations2 } from "@semiont/core";
+import { annotationId as annotationId4, resourceId as makeResourceId6, assembleAnnotation as assembleAnnotation3, applyBodyOperations as applyBodyOperations2 } from "@semiont/core";
 var AnnotationOperations = class {
   /**
    * Create a new annotation via EventBus → Stower
    */
-  static async createAnnotation(request, userId2, creator, eventBus) {
-    const { annotation } = assembleAnnotation2(request, creator);
-    const resId = makeResourceId5(request.target.source);
+  static async createAnnotation(request, userId3, creator, eventBus) {
+    const { annotation } = assembleAnnotation3(request, creator);
+    const resId = makeResourceId6(request.target.source);
     eventBus.get("mark:create").next({
       annotation,
-      userId: userId2,
+      _userId: userId3,
       resourceId: resId
     });
     return { annotation };
@@ -13661,10 +14155,10 @@ var AnnotationOperations = class {
   /**
    * Update annotation body via EventBus → Stower
    */
-  static async updateAnnotationBody(id, request, userId2, eventBus, kb) {
-    const resId = makeResourceId5(request.resourceId);
+  static async updateAnnotationBody(id, request, userId3, eventBus, kb) {
+    const resId = makeResourceId6(request.resourceId);
     const annotation = await AnnotationContext.getAnnotation(
-      annotationId2(id),
+      annotationId4(id),
       resId,
       kb
     );
@@ -13672,8 +14166,8 @@ var AnnotationOperations = class {
       throw new Error("Annotation not found");
     }
     eventBus.get("mark:update-body").next({
-      annotationId: annotationId2(id),
-      userId: userId2,
+      annotationId: annotationId4(id),
+      _userId: userId3,
       resourceId: resId,
       operations: request.operations
     });
@@ -13688,8 +14182,8 @@ var AnnotationOperations = class {
   /**
    * Delete an annotation via EventBus → Stower
    */
-  static async deleteAnnotation(id, resourceIdStr, userId2, eventBus, kb, logger) {
-    const resId = makeResourceId5(resourceIdStr);
+  static async deleteAnnotation(id, resourceIdStr, userId3, eventBus, kb, logger) {
+    const resId = makeResourceId6(resourceIdStr);
     const projection = await AnnotationContext.getResourceAnnotations(resId, kb);
     const annotation = projection.annotations.find((a) => a.id === id);
     if (!annotation) {
@@ -13697,8 +14191,8 @@ var AnnotationOperations = class {
     }
     logger?.debug("Removing annotation via EventBus", { annotationId: id });
     eventBus.get("mark:delete").next({
-      annotationId: annotationId2(id),
-      userId: userId2,
+      annotationId: annotationId4(id),
+      _userId: userId3,
       resourceId: resId
     });
     logger?.debug("Annotation delete event emitted");
@@ -13718,6 +14212,8 @@ export {
   Gatherer,
   GraphContext,
   LLMContext,
+  LocalContentTransport,
+  LocalTransport,
   Matcher,
   PACKAGE_NAME,
   ResourceContext,
@@ -13725,7 +14221,7 @@ export {
   Stower,
   VERSION,
   applyBodyOperations,
-  assembleAnnotation,
+  assembleAnnotation2 as assembleAnnotation,
   bootstrapEntityTypes,
   createKnowledgeBase,
   exportBackup,
@@ -13736,6 +14232,11 @@ export {
   importLinkedData,
   isBackupManifest,
   readEntityTypesProjection,
+  registerAnnotationAssemblyHandler,
+  registerAnnotationLookupHandlers,
+  registerBindUpdateBodyHandler,
+  registerBusHandlers,
+  registerJobCommandHandlers,
   startMakeMeaning,
   stopKnowledgeSystem,
   validateManifestVersion