@semiont/make-meaning 0.2.30-build.61 → 0.2.30-build.63

package/dist/index.js

@@ -1,727 +1,1230 @@
-// src/resource-context.ts
-import { FilesystemViewStorage } from "@semiont/event-sourcing";
+// src/service.ts
+import * as path from "path";
+import { JobQueue } from "@semiont/jobs";
+import { createEventStore as createEventStoreCore } from "@semiont/event-sourcing";
+import { FilesystemRepresentationStore as FilesystemRepresentationStore3 } from "@semiont/content";
+import { resourceId as makeResourceId2 } from "@semiont/core";
+import { getInferenceClient } from "@semiont/inference";
+import { getGraphDatabase } from "@semiont/graph";
+
+// src/jobs/reference-detection-worker.ts
+import { JobWorker } from "@semiont/jobs";
+import { generateAnnotationId } from "@semiont/event-sourcing";
+import { resourceIdToURI } from "@semiont/core";
+import {
+  getPrimaryRepresentation,
+  decodeRepresentation,
+  validateAndCorrectOffsets
+} from "@semiont/api-client";
+
+// src/detection/entity-extractor.ts
+async function extractEntities(exact, entityTypes, client, includeDescriptiveReferences = false) {
+  console.log("extractEntities called with:", {
+    textLength: exact.length,
+    entityTypes: Array.isArray(entityTypes) ? entityTypes.map((et) => typeof et === "string" ? et : et.type) : []
+  });
+  const entityTypesDescription = entityTypes.map((et) => {
+    if (typeof et === "string") {
+      return et;
+    }
+    return et.examples && et.examples.length > 0 ? `${et.type} (examples: ${et.examples.slice(0, 3).join(", ")})` : et.type;
+  }).join(", ");
+  const descriptiveReferenceGuidance = includeDescriptiveReferences ? `
+Include both:
+- Direct mentions (names, proper nouns)
+- Descriptive references (substantive phrases that refer to entities)
+
+For descriptive references, include:
+- Definite descriptions: "the Nobel laureate", "the tech giant", "the former president"
+- Role-based references: "the CEO", "the physicist", "the author", "the owner", "the contractor"
+- Epithets with context: "the Cupertino-based company", "the iPhone maker"
+- References to entities even when identity is unknown or unspecified
+
+Do NOT include:
+- Simple pronouns alone: he, she, it, they, him, her, them
+- Generic determiners alone: this, that, these, those
+- Possessives without substance: his, her, their, its
+
+Examples:
+- For "Marie Curie", include "the Nobel laureate" and "the physicist" but NOT "she"
+- For an unknown person, include "the owner" or "the contractor" (role-based references count even when identity is unspecified)
+` : `
+Find direct mentions only (names, proper nouns). Do not include pronouns or descriptive references.
+`;
+  const prompt = `Identify entity references in the following text. Look for mentions of: ${entityTypesDescription}.
+${descriptiveReferenceGuidance}
+Text to analyze:
+"""
+${exact}
+"""
+
+Return ONLY a JSON array of entities found. Each entity should have:
+- exact: the exact text span from the input
+- entityType: one of the provided entity types
+- startOffset: character position where the entity starts (0-indexed)
+- endOffset: character position where the entity ends
+- prefix: up to 32 characters of text immediately before the entity (helps identify correct occurrence)
+- suffix: up to 32 characters of text immediately after the entity (helps identify correct occurrence)
+
+Return empty array [] if no entities found.
+Do not include markdown formatting or code fences, just the raw JSON array.
+
+Example output:
+[{"exact":"Alice","entityType":"Person","startOffset":0,"endOffset":5,"prefix":"","suffix":" went to"},{"exact":"Paris","entityType":"Location","startOffset":20,"endOffset":25,"prefix":"went to ","suffix":" yesterday"}]`;
+  console.log("Sending entity extraction request");
+  const response = await client.generateTextWithMetadata(
+    prompt,
+    4e3,
+    // Increased to handle many entities without truncation
+    0.3
+    // Lower temperature for more consistent extraction
+  );
+  console.log("Got entity extraction response");
+  console.log("Entity extraction raw response length:", response.text.length);
+  try {
+    let jsonStr = response.text.trim();
+    if (jsonStr.startsWith("```")) {
+      jsonStr = jsonStr.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+    }
+    const entities = JSON.parse(jsonStr);
+    console.log("Parsed", entities.length, "entities from response");
+    if (response.stopReason === "max_tokens") {
+      const errorMsg = `AI response truncated: Found ${entities.length} entities but response hit max_tokens limit. Increase max_tokens or reduce resource size.`;
+      console.error(`\u274C ${errorMsg}`);
+      throw new Error(errorMsg);
+    }
+    return entities.map((entity, idx) => {
+      let startOffset = entity.startOffset;
+      let endOffset = entity.endOffset;
+      console.log(`
+[Entity ${idx + 1}/${entities.length}]`);
+      console.log(`  Type: ${entity.entityType}`);
+      console.log(`  Text: "${entity.exact}"`);
+      console.log(`  Offsets from AI: [${startOffset}, ${endOffset}]`);
+      const extractedText = exact.substring(startOffset, endOffset);
+      if (extractedText !== entity.exact) {
+        console.log(`  \u26A0\uFE0F  Offset mismatch!`);
+        console.log(`  Expected: "${entity.exact}"`);
+        console.log(`  Found at AI offsets [${startOffset}:${endOffset}]: "${extractedText}"`);
+        const contextStart = Math.max(0, startOffset - 50);
+        const contextEnd = Math.min(exact.length, endOffset + 50);
+        const contextBefore = exact.substring(contextStart, startOffset);
+        const contextAfter = exact.substring(endOffset, contextEnd);
+        console.log(`  Context: "...${contextBefore}[${extractedText}]${contextAfter}..."`);
+        console.log(`  Searching for exact match in resource...`);
+        let found = false;
+        if (entity.prefix || entity.suffix) {
+          console.log(`  Using LLM-provided context for disambiguation:`);
+          if (entity.prefix) console.log(`    Prefix: "${entity.prefix}"`);
+          if (entity.suffix) console.log(`    Suffix: "${entity.suffix}"`);
+          let searchPos = 0;
+          while ((searchPos = exact.indexOf(entity.exact, searchPos)) !== -1) {
+            const candidatePrefix = exact.substring(Math.max(0, searchPos - 32), searchPos);
+            const candidateSuffix = exact.substring(
+              searchPos + entity.exact.length,
+              Math.min(exact.length, searchPos + entity.exact.length + 32)
+            );
+            const prefixMatch = !entity.prefix || candidatePrefix.endsWith(entity.prefix);
+            const suffixMatch = !entity.suffix || candidateSuffix.startsWith(entity.suffix);
+            if (prefixMatch && suffixMatch) {
+              console.log(`  \u2705 Found match using context at offset ${searchPos} (diff: ${searchPos - startOffset})`);
+              console.log(`    Candidate prefix: "${candidatePrefix}"`);
+              console.log(`    Candidate suffix: "${candidateSuffix}"`);
+              startOffset = searchPos;
+              endOffset = searchPos + entity.exact.length;
+              found = true;
+              break;
+            }
+            searchPos++;
+          }
+          if (!found) {
+            console.log(`  \u26A0\uFE0F  No occurrence found with matching context`);
+          }
+        }
+        if (!found) {
+          const index = exact.indexOf(entity.exact);
+          if (index !== -1) {
+            console.log(`  \u26A0\uFE0F  Using first occurrence at offset ${index} (diff: ${index - startOffset})`);
+            startOffset = index;
+            endOffset = index + entity.exact.length;
+          } else {
+            console.log(`  \u274C Cannot find "${entity.exact}" anywhere in resource`);
+            console.log(`  Resource starts with: "${exact.substring(0, 200)}..."`);
+            return null;
+          }
+        }
+      } else {
+        console.log(`  \u2705 Offsets correct`);
+      }
+      return {
+        exact: entity.exact,
+        entityType: entity.entityType,
+        startOffset,
+        endOffset,
+        prefix: entity.prefix,
+        suffix: entity.suffix
+      };
+    }).filter((entity) => {
+      if (entity === null) {
+        console.log("\u274C Filtered entity: null");
+        return false;
+      }
+      if (entity.startOffset === void 0 || entity.endOffset === void 0) {
+        console.log(`\u274C Filtered entity "${entity.exact}": missing offsets`);
+        return false;
+      }
+      if (entity.startOffset < 0) {
+        console.log(`\u274C Filtered entity "${entity.exact}": negative startOffset (${entity.startOffset})`);
+        return false;
+      }
+      if (entity.endOffset > exact.length) {
+        console.log(`\u274C Filtered entity "${entity.exact}": endOffset (${entity.endOffset}) > text length (${exact.length})`);
+        return false;
+      }
+      const extractedText = exact.substring(entity.startOffset, entity.endOffset);
+      if (extractedText !== entity.exact) {
+        console.log(`\u274C Filtered entity "${entity.exact}": offset mismatch`);
+        console.log(`   Expected: "${entity.exact}"`);
+        console.log(`   Got at [${entity.startOffset}:${entity.endOffset}]: "${extractedText}"`);
+        return false;
+      }
+      console.log(`\u2705 Accepted entity "${entity.exact}" at [${entity.startOffset}:${entity.endOffset}]`);
+      return true;
+    });
+  } catch (error) {
+    console.error("Failed to parse entity extraction response:", error);
+    return [];
+  }
+}
+
+// src/jobs/reference-detection-worker.ts
 import { FilesystemRepresentationStore } from "@semiont/content";
-import { getPrimaryRepresentation, decodeRepresentation } from "@semiont/api-client";
-var ResourceContext = class {
-  /**
-   * Get resource metadata from view storage
-   */
-  static async getResourceMetadata(resourceId2, config) {
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
-    const viewStorage = new FilesystemViewStorage(basePath, projectRoot);
-    const view = await viewStorage.get(resourceId2);
-    if (!view) {
-      return null;
+var ReferenceDetectionWorker = class extends JobWorker {
+  constructor(jobQueue, config, eventStore, inferenceClient) {
+    super(jobQueue);
+    this.config = config;
+    this.eventStore = eventStore;
+    this.inferenceClient = inferenceClient;
+  }
+  getWorkerName() {
+    return "ReferenceDetectionWorker";
+  }
+  canProcessJob(job) {
+    return job.metadata.type === "detection";
+  }
+  async executeJob(job) {
+    if (job.metadata.type !== "detection") {
+      throw new Error(`Invalid job type: ${job.metadata.type}`);
     }
-    return view.resource;
+    if (job.status !== "running") {
+      throw new Error(`Job must be in running state to execute, got: ${job.status}`);
+    }
+    await this.processDetectionJob(job);
   }
   /**
-   * List all resources by scanning view storage
+   * Detect entity references in resource using AI
+   * Self-contained implementation for reference detection
+   *
+   * Public for testing charset handling - see entity-detection-charset.test.ts
    */
-  static async listResources(filters, config) {
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
-    const viewStorage = new FilesystemViewStorage(basePath, projectRoot);
-    const allViews = await viewStorage.getAll();
-    const resources = [];
-    for (const view of allViews) {
-      const doc = view.resource;
-      if (filters?.archived !== void 0 && doc.archived !== filters.archived) {
-        continue;
-      }
-      if (filters?.search) {
-        const searchLower = filters.search.toLowerCase();
-        if (!doc.name.toLowerCase().includes(searchLower)) {
-          continue;
+  async detectReferences(resource, entityTypes, includeDescriptiveReferences = false) {
+    console.log(`Detecting entities of types: ${entityTypes.join(", ")}${includeDescriptiveReferences ? " (including descriptive references)" : ""}`);
+    const detectedAnnotations = [];
+    const primaryRep = getPrimaryRepresentation(resource);
+    if (!primaryRep) return detectedAnnotations;
+    const mediaType = primaryRep.mediaType;
+    const baseMediaType = mediaType?.split(";")[0]?.trim() || "";
+    if (baseMediaType === "text/plain" || baseMediaType === "text/markdown") {
+      if (!primaryRep.checksum || !primaryRep.mediaType) return detectedAnnotations;
+      const basePath = this.config.services.filesystem.path;
+      const projectRoot = this.config._metadata?.projectRoot;
+      const repStore = new FilesystemRepresentationStore({ basePath }, projectRoot);
+      const contentBuffer = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
+      const content = decodeRepresentation(contentBuffer, primaryRep.mediaType);
+      const extractedEntities = await extractEntities(content, entityTypes, this.inferenceClient, includeDescriptiveReferences);
+      for (const entity of extractedEntities) {
+        try {
+          const validated = validateAndCorrectOffsets(
+            content,
+            entity.startOffset,
+            entity.endOffset,
+            entity.exact
+          );
+          const annotation = {
+            annotation: {
+              selector: {
+                start: validated.start,
+                end: validated.end,
+                exact: validated.exact,
+                prefix: validated.prefix,
+                suffix: validated.suffix
+              },
+              entityTypes: [entity.entityType]
+            }
+          };
+          detectedAnnotations.push(annotation);
+        } catch (error) {
+          console.warn(`[ReferenceDetectionWorker] Skipping invalid entity "${entity.exact}":`, error);
         }
       }
-      resources.push(doc);
     }
-    resources.sort((a, b) => {
-      const aTime = a.dateCreated ? new Date(a.dateCreated).getTime() : 0;
-      const bTime = b.dateCreated ? new Date(b.dateCreated).getTime() : 0;
-      return bTime - aTime;
-    });
-    return resources;
+    return detectedAnnotations;
   }
-  /**
-   * Add content previews to resources (for search results)
-   * Retrieves and decodes the first 200 characters of each resource's primary representation
-   */
-  static async addContentPreviews(resources, config) {
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
-    const repStore = new FilesystemRepresentationStore({ basePath }, projectRoot);
-    return await Promise.all(
-      resources.map(async (doc) => {
+  async processDetectionJob(job) {
+    console.log(`[ReferenceDetectionWorker] Processing detection for resource ${job.params.resourceId} (job: ${job.metadata.id})`);
+    console.log(`[ReferenceDetectionWorker] \u{1F50D} Entity types: ${job.params.entityTypes.join(", ")}`);
+    const resource = await ResourceContext.getResourceMetadata(job.params.resourceId, this.config);
+    if (!resource) {
+      throw new Error(`Resource ${job.params.resourceId} not found`);
+    }
+    let totalFound = 0;
+    let totalEmitted = 0;
+    let totalErrors = 0;
+    let updatedJob = {
+      ...job,
+      progress: {
+        totalEntityTypes: job.params.entityTypes.length,
+        processedEntityTypes: 0,
+        entitiesFound: 0,
+        entitiesEmitted: 0
+      }
+    };
+    await this.updateJobProgress(updatedJob);
+    for (let i = 0; i < job.params.entityTypes.length; i++) {
+      const entityType = job.params.entityTypes[i];
+      if (!entityType) continue;
+      console.log(`[ReferenceDetectionWorker] \u{1F916} [${i + 1}/${job.params.entityTypes.length}] Detecting ${entityType}...`);
+      const detectedAnnotations = await this.detectReferences(resource, [entityType], job.params.includeDescriptiveReferences);
+      totalFound += detectedAnnotations.length;
+      console.log(`[ReferenceDetectionWorker] \u2705 Found ${detectedAnnotations.length} ${entityType} entities`);
+      for (let idx = 0; idx < detectedAnnotations.length; idx++) {
+        const detected = detectedAnnotations[idx];
+        if (!detected) {
+          console.warn(`[ReferenceDetectionWorker] Skipping undefined entity at index ${idx}`);
+          continue;
+        }
+        let referenceId;
         try {
-          const primaryRep = getPrimaryRepresentation(doc);
-          if (primaryRep?.checksum && primaryRep?.mediaType) {
-            const contentBuffer = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
-            const contentPreview = decodeRepresentation(contentBuffer, primaryRep.mediaType).slice(0, 200);
-            return { ...doc, content: contentPreview };
+          const backendUrl = this.config.services.backend?.publicURL;
+          if (!backendUrl) {
+            throw new Error("Backend publicURL not configured");
           }
-          return { ...doc, content: "" };
-        } catch {
-          return { ...doc, content: "" };
+          referenceId = generateAnnotationId(backendUrl);
+        } catch (error) {
+          console.error(`[ReferenceDetectionWorker] Failed to generate annotation ID:`, error);
+          throw new Error("Configuration error: Backend publicURL not set");
         }
-      })
-    );
+        try {
+          await this.eventStore.appendEvent({
+            type: "annotation.added",
+            resourceId: job.params.resourceId,
+            userId: job.metadata.userId,
+            version: 1,
+            payload: {
+              annotation: {
+                "@context": "http://www.w3.org/ns/anno.jsonld",
+                "type": "Annotation",
+                id: referenceId,
+                motivation: "linking",
+                target: {
+                  source: resourceIdToURI(job.params.resourceId, this.config.services.backend.publicURL),
+                  // Convert to full URI
+                  selector: [
+                    {
+                      type: "TextPositionSelector",
+                      start: detected.annotation.selector.start,
+                      end: detected.annotation.selector.end
+                    },
+                    {
+                      type: "TextQuoteSelector",
+                      exact: detected.annotation.selector.exact,
+                      ...detected.annotation.selector.prefix && { prefix: detected.annotation.selector.prefix },
+                      ...detected.annotation.selector.suffix && { suffix: detected.annotation.selector.suffix }
+                    }
+                  ]
+                },
+                body: (detected.annotation.entityTypes || []).map((et) => ({
+                  type: "TextualBody",
+                  value: et,
+                  purpose: "tagging"
+                })),
+                modified: (/* @__PURE__ */ new Date()).toISOString()
+              }
+            }
+          });
+          totalEmitted++;
+          if ((idx + 1) % 10 === 0 || idx === detectedAnnotations.length - 1) {
+            console.log(`[ReferenceDetectionWorker] \u{1F4E4} Emitted ${idx + 1}/${detectedAnnotations.length} events for ${entityType}`);
+          }
+        } catch (error) {
+          totalErrors++;
+          console.error(`[ReferenceDetectionWorker] \u274C Failed to emit event for ${referenceId}:`, error);
+        }
+      }
+      console.log(`[ReferenceDetectionWorker] \u2705 Completed ${entityType}: ${detectedAnnotations.length} found, ${detectedAnnotations.length - (totalErrors - (totalFound - totalEmitted))} emitted`);
+      updatedJob = {
+        ...updatedJob,
+        progress: {
+          totalEntityTypes: job.params.entityTypes.length,
+          processedEntityTypes: i + 1,
+          currentEntityType: entityType,
+          entitiesFound: totalFound,
+          entitiesEmitted: totalEmitted
+        }
+      };
+      await this.updateJobProgress(updatedJob);
+    }
+    console.log(`[ReferenceDetectionWorker] \u2705 Detection complete: ${totalFound} entities found, ${totalEmitted} events emitted, ${totalErrors} errors`);
+  }
+  async handleJobFailure(job, error) {
+    await super.handleJobFailure(job, error);
+    if (job.status === "failed" && job.metadata.type === "detection") {
+      const detJob = job;
+      await this.eventStore.appendEvent({
+        type: "job.failed",
+        resourceId: detJob.params.resourceId,
+        userId: detJob.metadata.userId,
+        version: 1,
+        payload: {
+          jobId: detJob.metadata.id,
+          jobType: detJob.metadata.type,
+          error: "Entity detection failed. Please try again later."
+        }
+      });
+    }
   }
-};
-
-// src/annotation-context.ts
-import { generateResourceSummary, generateText } from "@semiont/inference";
-import {
-  getBodySource,
-  getTargetSource,
-  getTargetSelector,
-  getResourceEntityTypes,
-  getTextPositionSelector,
-  getPrimaryRepresentation as getPrimaryRepresentation2,
-  decodeRepresentation as decodeRepresentation2
-} from "@semiont/api-client";
-import { FilesystemRepresentationStore as FilesystemRepresentationStore2 } from "@semiont/content";
-import { FilesystemViewStorage as FilesystemViewStorage2 } from "@semiont/event-sourcing";
-import { resourceId as createResourceId, uriToResourceId } from "@semiont/core";
-import { getEntityTypes } from "@semiont/ontology";
-var AnnotationContext = class {
   /**
-   * Build LLM context for an annotation
-   *
-   * @param annotationUri - Full annotation URI (e.g., http://localhost:4000/annotations/abc123)
-   * @param resourceId - Source resource ID
-   * @param config - Application configuration
-   * @param options - Context building options
-   * @returns Rich context for LLM processing
-   * @throws Error if annotation or resource not found
+   * Update job progress and emit events to Event Store
+   * Overrides base class to also emit job progress events
    */
-  static async buildLLMContext(annotationUri2, resourceId2, config, options = {}) {
-    const {
-      includeSourceContext = true,
-      includeTargetContext = true,
-      contextWindow = 1e3
-    } = options;
-    if (contextWindow < 100 || contextWindow > 5e3) {
-      throw new Error("contextWindow must be between 100 and 5000");
-    }
-    console.log(`[AnnotationContext] buildLLMContext called with annotationUri=${annotationUri2}, resourceId=${resourceId2}`);
-    const basePath = config.services.filesystem.path;
-    console.log(`[AnnotationContext] basePath=${basePath}`);
-    const projectRoot = config._metadata?.projectRoot;
-    const viewStorage = new FilesystemViewStorage2(basePath, projectRoot);
-    const repStore = new FilesystemRepresentationStore2({ basePath }, projectRoot);
-    console.log(`[AnnotationContext] Getting view for resourceId=${resourceId2}`);
-    let sourceView;
-    try {
-      sourceView = await viewStorage.get(resourceId2);
-      console.log(`[AnnotationContext] Got view:`, !!sourceView);
-      if (!sourceView) {
-        throw new Error("Source resource not found");
-      }
-    } catch (error) {
-      console.error(`[AnnotationContext] Error getting view:`, error);
-      throw error;
-    }
-    console.log(`[AnnotationContext] Looking for annotation ${annotationUri2} in resource ${resourceId2}`);
-    console.log(`[AnnotationContext] View has ${sourceView.annotations.annotations.length} annotations`);
-    console.log(`[AnnotationContext] First 5 annotation IDs:`, sourceView.annotations.annotations.slice(0, 5).map((a) => a.id));
-    const annotation = sourceView.annotations.annotations.find((a) => a.id === annotationUri2);
-    console.log(`[AnnotationContext] Found annotation:`, !!annotation);
-    if (!annotation) {
-      throw new Error("Annotation not found in view");
-    }
-    const targetSource = getTargetSource(annotation.target);
-    const targetResourceId = targetSource.split("/").pop();
-    console.log(`[AnnotationContext] Target source: ${targetSource}, Expected resource ID: ${resourceId2}, Extracted ID: ${targetResourceId}`);
-    if (targetResourceId !== resourceId2) {
-      throw new Error(`Annotation target resource ID (${targetResourceId}) does not match expected resource ID (${resourceId2})`);
+  async updateJobProgress(job) {
+    await super.updateJobProgress(job);
+    if (job.metadata.type !== "detection") {
+      return;
     }
-    const sourceDoc = sourceView.resource;
-    const bodySource = getBodySource(annotation.body);
-    let targetDoc = null;
-    if (bodySource) {
-      const parts = bodySource.split("/");
-      const lastPart = parts[parts.length - 1];
-      if (!lastPart) {
-        throw new Error(`Invalid body source URI: ${bodySource}`);
-      }
-      const targetResourceId2 = createResourceId(lastPart);
-      const targetView = await viewStorage.get(targetResourceId2);
-      targetDoc = targetView?.resource || null;
+    if (job.status !== "running") {
+      return;
     }
-    let sourceContext;
-    if (includeSourceContext) {
-      const primaryRep = getPrimaryRepresentation2(sourceDoc);
-      if (!primaryRep?.checksum || !primaryRep?.mediaType) {
-        throw new Error("Source content not found");
-      }
-      const sourceContent = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
-      const contentStr = decodeRepresentation2(sourceContent, primaryRep.mediaType);
-      const targetSelectorRaw = getTargetSelector(annotation.target);
-      const targetSelector = Array.isArray(targetSelectorRaw) ? targetSelectorRaw[0] : targetSelectorRaw;
-      console.log(`[AnnotationContext] Target selector type:`, targetSelector?.type);
-      if (!targetSelector) {
-        console.warn(`[AnnotationContext] No target selector found`);
-      } else if (targetSelector.type === "TextPositionSelector") {
-        const selector = targetSelector;
-        const start = selector.start;
-        const end = selector.end;
-        const before = contentStr.slice(Math.max(0, start - contextWindow), start);
-        const selected = contentStr.slice(start, end);
-        const after = contentStr.slice(end, Math.min(contentStr.length, end + contextWindow));
-        sourceContext = { before, selected, after };
-        console.log(`[AnnotationContext] Built source context using TextPositionSelector (${start}-${end})`);
-      } else if (targetSelector.type === "TextQuoteSelector") {
-        const selector = targetSelector;
-        const exact = selector.exact;
-        const index = contentStr.indexOf(exact);
-        if (index !== -1) {
-          const start = index;
-          const end = index + exact.length;
-          const before = contentStr.slice(Math.max(0, start - contextWindow), start);
-          const selected = exact;
-          const after = contentStr.slice(end, Math.min(contentStr.length, end + contextWindow));
-          sourceContext = { before, selected, after };
-          console.log(`[AnnotationContext] Built source context using TextQuoteSelector (found at ${index})`);
-        } else {
-          console.warn(`[AnnotationContext] TextQuoteSelector exact text not found in content: "${exact.substring(0, 50)}..."`);
+    const detJob = job;
+    const baseEvent = {
+      resourceId: detJob.params.resourceId,
+      userId: detJob.metadata.userId,
+      version: 1
+    };
+    const isFirstUpdate = detJob.progress.processedEntityTypes === 0;
+    const isFinalUpdate = detJob.progress.processedEntityTypes === detJob.progress.totalEntityTypes && detJob.progress.totalEntityTypes > 0;
+    if (isFirstUpdate) {
+      await this.eventStore.appendEvent({
+        type: "job.started",
+        ...baseEvent,
+        payload: {
+          jobId: detJob.metadata.id,
+          jobType: detJob.metadata.type,
+          totalSteps: detJob.params.entityTypes.length
         }
-      } else {
-        console.warn(`[AnnotationContext] Unknown selector type: ${targetSelector.type}`);
-      }
+      });
+    } else if (isFinalUpdate) {
+      await this.eventStore.appendEvent({
+        type: "job.completed",
+        ...baseEvent,
+        payload: {
+          jobId: detJob.metadata.id,
+          jobType: detJob.metadata.type,
+          foundCount: detJob.progress.entitiesFound
+        }
+      });
+    } else {
+      const percentage = Math.round(detJob.progress.processedEntityTypes / detJob.progress.totalEntityTypes * 100);
+      await this.eventStore.appendEvent({
+        type: "job.progress",
+        ...baseEvent,
+        payload: {
+          jobId: detJob.metadata.id,
+          jobType: detJob.metadata.type,
+          percentage,
+          currentStep: detJob.progress.currentEntityType,
+          processedSteps: detJob.progress.processedEntityTypes,
+          totalSteps: detJob.progress.totalEntityTypes,
+          foundCount: detJob.progress.entitiesFound
+        }
+      });
     }
-    let targetContext;
-    if (includeTargetContext && targetDoc) {
-      const targetRep = getPrimaryRepresentation2(targetDoc);
-      if (targetRep?.checksum && targetRep?.mediaType) {
-        const targetContent = await repStore.retrieve(targetRep.checksum, targetRep.mediaType);
-        const contentStr = decodeRepresentation2(targetContent, targetRep.mediaType);
-        targetContext = {
-          content: contentStr.slice(0, contextWindow * 2),
-          summary: await generateResourceSummary(targetDoc.name, contentStr, getResourceEntityTypes(targetDoc), config)
-        };
+  }
+};
+
+// src/jobs/generation-worker.ts
+import { JobWorker as JobWorker2 } from "@semiont/jobs";
+import { FilesystemRepresentationStore as FilesystemRepresentationStore2 } from "@semiont/content";
+
+// src/generation/resource-generation.ts
+import { getLocaleEnglishName } from "@semiont/api-client";
+function getLanguageName(locale) {
+  return getLocaleEnglishName(locale) || locale;
+}
+async function generateResourceFromTopic(topic, entityTypes, client, userPrompt, locale, context, temperature, maxTokens) {
+  console.log("generateResourceFromTopic called with:", {
+    topic: topic.substring(0, 100),
+    entityTypes,
+    hasUserPrompt: !!userPrompt,
+    locale,
+    hasContext: !!context,
+    temperature,
+    maxTokens
+  });
+  const finalTemperature = temperature ?? 0.7;
+  const finalMaxTokens = maxTokens ?? 500;
+  const languageInstruction = locale && locale !== "en" ? `
+
+IMPORTANT: Write the entire resource in ${getLanguageName(locale)}.` : "";
+  let contextSection = "";
+  if (context?.sourceContext) {
+    const { before, selected, after } = context.sourceContext;
+    contextSection = `
+
+Source document context:
+---
+${before ? `...${before}` : ""}
+**[${selected}]**
+${after ? `${after}...` : ""}
+---
+`;
+  }
+  const prompt = `Generate a concise, informative resource about "${topic}".
+${entityTypes.length > 0 ? `Focus on these entity types: ${entityTypes.join(", ")}.` : ""}
+${userPrompt ? `Additional context: ${userPrompt}` : ""}${contextSection}${languageInstruction}
+
+Requirements:
+- Start with a clear heading (# Title)
+- Write 2-3 paragraphs of substantive content
+- Be factual and informative
+- Use markdown formatting
+- Return ONLY the markdown content, no JSON, no code fences, no additional wrapper`;
+  const parseResponse = (response2) => {
+    let content = response2.trim();
+    if (content.startsWith("```markdown") || content.startsWith("```md")) {
+      content = content.slice(content.indexOf("\n") + 1);
+      const endIndex = content.lastIndexOf("```");
+      if (endIndex !== -1) {
+        content = content.slice(0, endIndex);
       }
-    }
-    const suggestedResolution = void 0;
-    const generationContext = sourceContext ? {
-      sourceContext: {
-        before: sourceContext.before || "",
-        selected: sourceContext.selected,
-        after: sourceContext.after || ""
-      },
-      metadata: {
-        resourceType: "document",
-        language: sourceDoc.language,
-        entityTypes: getEntityTypes(annotation)
+    } else if (content.startsWith("```")) {
+      content = content.slice(3);
+      const endIndex = content.lastIndexOf("```");
+      if (endIndex !== -1) {
+        content = content.slice(0, endIndex);
       }
-    } : void 0;
-    const response = {
-      annotation,
-      sourceResource: sourceDoc,
-      targetResource: targetDoc,
-      ...generationContext ? { context: generationContext } : {},
-      ...sourceContext ? { sourceContext } : {},
-      // Keep for backward compatibility
-      ...targetContext ? { targetContext } : {},
-      ...suggestedResolution ? { suggestedResolution } : {}
+    }
+    content = content.trim();
+    return {
+      title: topic,
+      content
     };
-    return response;
+  };
+  console.log("Sending prompt to inference (length:", prompt.length, "chars)", "temp:", finalTemperature, "maxTokens:", finalMaxTokens);
+  const response = await client.generateText(prompt, finalMaxTokens, finalTemperature);
+  console.log("Got raw response (length:", response.length, "chars)");
+  const result = parseResponse(response);
+  console.log("Parsed result:", {
+    hasTitle: !!result.title,
+    titleLength: result.title?.length,
+    hasContent: !!result.content,
+    contentLength: result.content?.length
+  });
+  return result;
+}
+async function generateResourceSummary(resourceName, content, entityTypes, client) {
+  const truncatedContent = content.length > 2e3 ? content.substring(0, 2e3) + "..." : content;
+  const prompt = `Create a brief, intelligent summary of this resource titled "${resourceName}".
+${entityTypes.length > 0 ? `Key entity types: ${entityTypes.join(", ")}` : ""}
+
+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);
+}
+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.
+
+Format as a simple list, one suggestion per line.`;
+  const response = await client.generateText(prompt, 200, 0.8);
+  if (!response) {
+    return null;
   }
-  /**
-   * Get resource annotations from view storage (fast path)
-   * Throws if view missing
-   */
-  static async getResourceAnnotations(resourceId2, config) {
-    if (!config.services?.filesystem?.path) {
-      throw new Error("Filesystem path not found in configuration");
-    }
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
-    const viewStorage = new FilesystemViewStorage2(basePath, projectRoot);
-    const view = await viewStorage.get(resourceId2);
-    if (!view) {
-      throw new Error(`Resource ${resourceId2} not found in view storage`);
-    }
-    return view.annotations;
+  return response.split("\n").map((line) => line.replace(/^[-*•]\s*/, "").trim()).filter((line) => line.length > 0).slice(0, 3);
+}
+
+// src/jobs/generation-worker.ts
+import {
+  getTargetSelector,
+  getExactText,
+  resourceUri,
+  annotationUri
+} from "@semiont/api-client";
+import { getEntityTypes } from "@semiont/ontology";
+import {
+  CREATION_METHODS,
+  generateUuid,
+  resourceId,
+  annotationId
+} from "@semiont/core";
+var GenerationWorker = class extends JobWorker2 {
+  constructor(jobQueue, config, eventStore, inferenceClient) {
+    super(jobQueue);
+    this.config = config;
+    this.eventStore = eventStore;
+    this.inferenceClient = inferenceClient;
   }
-  /**
-   * Get all annotations
-   * @returns Array of all annotation objects
-   */
-  static async getAllAnnotations(resourceId2, config) {
-    const annotations = await this.getResourceAnnotations(resourceId2, config);
-    return await this.enrichResolvedReferences(annotations.annotations, config);
+  getWorkerName() {
+    return "GenerationWorker";
   }
-  /**
-   * Enrich reference annotations with resolved document names
-   * Adds _resolvedDocumentName property to annotations that link to documents
-   * @private
-   */
-  static async enrichResolvedReferences(annotations, config) {
-    if (!config.services?.filesystem?.path) {
-      return annotations;
+  canProcessJob(job) {
+    return job.metadata.type === "generation";
+  }
+  async executeJob(job) {
+    if (job.metadata.type !== "generation") {
+      throw new Error(`Invalid job type: ${job.metadata.type}`);
     }
-    const resolvedUris = /* @__PURE__ */ new Set();
-    for (const ann of annotations) {
-      if (ann.motivation === "linking" && ann.body) {
-        const body = Array.isArray(ann.body) ? ann.body : [ann.body];
-        for (const item of body) {
-          if (item.purpose === "linking" && item.source) {
-            resolvedUris.add(item.source);
-          }
-        }
+    if (job.status !== "running") {
+      throw new Error(`Job must be in running state to execute, got: ${job.status}`);
+    }
+    await this.processGenerationJob(job);
+  }
+  async processGenerationJob(job) {
+    console.log(`[GenerationWorker] Processing generation for reference ${job.params.referenceId} (job: ${job.metadata.id})`);
+    const basePath = this.config.services.filesystem.path;
+    const projectRoot = this.config._metadata?.projectRoot;
+    const repStore = new FilesystemRepresentationStore2({ basePath }, projectRoot);
+    let updatedJob = {
+      ...job,
+      progress: {
+        stage: "fetching",
+        percentage: 20,
+        message: "Fetching source resource..."
       }
+    };
+    console.log(`[GenerationWorker] \u{1F4E5} ${updatedJob.progress.message}`);
+    await this.updateJobProgress(updatedJob);
+    const { FilesystemViewStorage: FilesystemViewStorage3 } = await import("@semiont/event-sourcing");
+    const viewStorage = new FilesystemViewStorage3(basePath, projectRoot);
+    const view = await viewStorage.get(job.params.sourceResourceId);
+    if (!view) {
+      throw new Error(`Resource ${job.params.sourceResourceId} not found`);
     }
-    if (resolvedUris.size === 0) {
-      return annotations;
+    const projection = view.annotations;
+    const expectedAnnotationUri = `${this.config.services.backend.publicURL}/annotations/${job.params.referenceId}`;
+    const annotation = projection.annotations.find(
+      (a) => a.id === expectedAnnotationUri && a.motivation === "linking"
+    );
+    if (!annotation) {
+      throw new Error(`Annotation ${job.params.referenceId} not found in resource ${job.params.sourceResourceId}`);
     }
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
-    const viewStorage = new FilesystemViewStorage2(basePath, projectRoot);
-    const metadataPromises = Array.from(resolvedUris).map(async (uri) => {
-      const docId = uri.split("/resources/")[1];
-      if (!docId) return null;
-      try {
-        const view = await viewStorage.get(docId);
-        if (view?.resource?.name) {
-          return {
-            uri,
-            metadata: {
-              name: view.resource.name,
-              mediaType: view.resource.mediaType
-            }
-          };
-        }
-      } catch (e) {
+    const sourceResource = await ResourceContext.getResourceMetadata(job.params.sourceResourceId, this.config);
+    if (!sourceResource) {
+      throw new Error(`Source resource ${job.params.sourceResourceId} not found`);
+    }
+    const targetSelector = getTargetSelector(annotation.target);
+    const resourceName = job.params.title || (targetSelector ? getExactText(targetSelector) : "") || "New Resource";
+    console.log(`[GenerationWorker] Generating resource: "${resourceName}"`);
+    if (!job.params.context) {
+      throw new Error("Generation context is required but was not provided in job");
+    }
+    console.log(`[GenerationWorker] Using pre-fetched context: ${job.params.context.sourceContext?.before?.length || 0} chars before, ${job.params.context.sourceContext?.selected?.length || 0} chars selected, ${job.params.context.sourceContext?.after?.length || 0} chars after`);
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "generating",
+        percentage: 40,
+        message: "Creating content with AI..."
       }
-      return null;
+    };
+    console.log(`[GenerationWorker] \u{1F916} ${updatedJob.progress.message}`);
+    await this.updateJobProgress(updatedJob);
+    const prompt = job.params.prompt || `Create a comprehensive resource about "${resourceName}"`;
+    const annotationEntityTypes = getEntityTypes({ body: annotation.body });
+    const generatedContent = await generateResourceFromTopic(
+      resourceName,
+      job.params.entityTypes || annotationEntityTypes,
+      this.inferenceClient,
+      prompt,
+      job.params.language,
+      job.params.context,
+      // NEW - context from job (passed from modal)
+      job.params.temperature,
+      // NEW - from job
+      job.params.maxTokens
+      // NEW - from job
+    );
+    console.log(`[GenerationWorker] \u2705 Generated ${generatedContent.content.length} bytes of content`);
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "generating",
+        percentage: 70,
+        message: "Content ready, creating resource..."
+      }
+    };
+    await this.updateJobProgress(updatedJob);
+    const rId = resourceId(generateUuid());
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 85,
+        message: "Saving resource..."
+      }
+    };
+    console.log(`[GenerationWorker] \u{1F4BE} ${updatedJob.progress.message}`);
+    await this.updateJobProgress(updatedJob);
+    const storedRep = await repStore.store(Buffer.from(generatedContent.content), {
+      mediaType: "text/markdown",
+      rel: "original"
     });
-    const results = await Promise.all(metadataPromises);
-    const uriToMetadata = /* @__PURE__ */ new Map();
-    for (const result of results) {
-      if (result) {
-        uriToMetadata.set(result.uri, result.metadata);
+    console.log(`[GenerationWorker] \u2705 Saved resource representation to filesystem: ${rId}`);
+    await this.eventStore.appendEvent({
+      type: "resource.created",
+      resourceId: rId,
+      userId: job.metadata.userId,
+      version: 1,
+      payload: {
+        name: resourceName,
+        format: "text/markdown",
+        contentChecksum: storedRep.checksum,
+        creationMethod: CREATION_METHODS.GENERATED,
+        entityTypes: job.params.entityTypes || annotationEntityTypes,
+        language: job.params.language,
+        isDraft: true,
+        generatedFrom: job.params.referenceId,
+        generationPrompt: void 0
+        // Could be added if we track the prompt
       }
-    }
-    return annotations.map((ann) => {
-      if (ann.motivation === "linking" && ann.body) {
-        const body = Array.isArray(ann.body) ? ann.body : [ann.body];
-        for (const item of body) {
-          if (item.purpose === "linking" && item.source) {
-            const metadata = uriToMetadata.get(item.source);
-            if (metadata) {
-              return {
-                ...ann,
-                _resolvedDocumentName: metadata.name,
-                _resolvedDocumentMediaType: metadata.mediaType
-              };
-            }
-          }
-        }
+    });
+    console.log(`[GenerationWorker] Emitted resource.created event for ${rId}`);
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "linking",
+        percentage: 95,
+        message: "Linking reference...",
+        resultResourceId: rId
+        // Store for job.completed event
+      }
+    };
+    console.log(`[GenerationWorker] \u{1F517} ${updatedJob.progress.message}`);
+    await this.updateJobProgress(updatedJob);
+    const newResourceUri = resourceUri(`${this.config.services.backend.publicURL}/resources/${rId}`);
+    const operations = [{
+      op: "add",
+      item: {
+        type: "SpecificResource",
+        source: newResourceUri,
+        purpose: "linking"
+      }
+    }];
+    const annotationIdSegment = job.params.referenceId.split("/").pop();
+    await this.eventStore.appendEvent({
+      type: "annotation.body.updated",
+      resourceId: job.params.sourceResourceId,
+      userId: job.metadata.userId,
+      version: 1,
+      payload: {
+        annotationId: annotationId(annotationIdSegment),
+        operations
       }
-      return ann;
     });
-  }
-  /**
-   * Get resource stats (version info)
-   * @returns Version and timestamp info for the annotations
-   */
-  static async getResourceStats(resourceId2, config) {
-    const annotations = await this.getResourceAnnotations(resourceId2, config);
-    return {
-      resourceId: annotations.resourceId,
-      version: annotations.version,
-      updatedAt: annotations.updatedAt
+    console.log(`[GenerationWorker] \u2705 Emitted annotation.body.updated event linking ${job.params.referenceId} \u2192 ${rId}`);
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "linking",
+        percentage: 100,
+        message: "Complete!",
+        resultResourceId: rId
+        // Store for job.completed event
+      }
     };
+    await this.updateJobProgress(updatedJob);
+    console.log(`[GenerationWorker] \u2705 Generation complete: created resource ${rId}`);
   }
   /**
-   * Check if resource exists in view storage
+   * Update job progress and emit events to Event Store
+   * Overrides base class to also emit job progress events
    */
-  static async resourceExists(resourceId2, config) {
-    if (!config.services?.filesystem?.path) {
-      throw new Error("Filesystem path not found in configuration");
+  async updateJobProgress(job) {
+    await super.updateJobProgress(job);
+    if (job.metadata.type !== "generation") {
+      return;
+    }
+    if (job.status !== "running") {
+      return;
+    }
+    const genJob = job;
+    const baseEvent = {
+      resourceId: genJob.params.sourceResourceId,
+      userId: genJob.metadata.userId,
+      version: 1
+    };
+    if (genJob.progress.stage === "fetching" && genJob.progress.percentage === 20) {
+      await this.eventStore.appendEvent({
+        type: "job.started",
+        ...baseEvent,
+        payload: {
+          jobId: genJob.metadata.id,
+          jobType: genJob.metadata.type,
+          totalSteps: 5
+          // fetching, generating, creating, linking, complete
+        }
+      });
+    } else if (genJob.progress.stage === "linking" && genJob.progress.percentage === 100) {
+      await this.eventStore.appendEvent({
+        type: "job.completed",
+        ...baseEvent,
+        payload: {
+          jobId: genJob.metadata.id,
+          jobType: genJob.metadata.type,
+          resultResourceId: genJob.progress.resultResourceId,
+          annotationUri: annotationUri(`${this.config.services.backend.publicURL}/annotations/${genJob.params.referenceId}`)
+        }
+      });
+    } else {
+      await this.eventStore.appendEvent({
+        type: "job.progress",
+        ...baseEvent,
+        payload: {
+          jobId: genJob.metadata.id,
+          jobType: genJob.metadata.type,
+          currentStep: genJob.progress.stage,
+          percentage: genJob.progress.percentage,
+          message: genJob.progress.message
+        }
+      });
     }
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
-    const viewStorage = new FilesystemViewStorage2(basePath, projectRoot);
-    return await viewStorage.exists(resourceId2);
   }
-  /**
-   * Get a single annotation by ID
-   * O(1) lookup using resource ID to access view storage
-   */
-  static async getAnnotation(annotationId2, resourceId2, config) {
-    const annotations = await this.getResourceAnnotations(resourceId2, config);
-    return annotations.annotations.find((a) => {
-      const shortId = a.id.split("/").pop();
-      return shortId === annotationId2;
-    }) || null;
+};
+
+// src/jobs/highlight-detection-worker.ts
+import { JobWorker as JobWorker3 } from "@semiont/jobs";
+import { generateAnnotationId as generateAnnotationId2 } from "@semiont/event-sourcing";
+import { resourceIdToURI as resourceIdToURI2 } from "@semiont/core";
+import { userId } from "@semiont/core";
+var HighlightDetectionWorker = class extends JobWorker3 {
+  constructor(jobQueue, config, eventStore, inferenceClient) {
+    super(jobQueue);
+    this.config = config;
+    this.eventStore = eventStore;
+    this.inferenceClient = inferenceClient;
   }
-  /**
-   * List annotations with optional filtering
-   * @param filters - Optional filters like resourceId and type
-   * @throws Error if resourceId not provided (cross-resource queries not supported in view storage)
-   */
-  static async listAnnotations(filters, config) {
-    if (!filters?.resourceId) {
-      throw new Error("resourceId is required for annotation listing - cross-resource queries not supported in view storage");
+  isFirstProgress = true;
+  getWorkerName() {
+    return "HighlightDetectionWorker";
+  }
+  canProcessJob(job) {
+    return job.metadata.type === "highlight-detection";
+  }
+  async executeJob(job) {
+    if (job.metadata.type !== "highlight-detection") {
+      throw new Error(`Invalid job type: ${job.metadata.type}`);
     }
-    return await this.getAllAnnotations(filters.resourceId, config);
+    if (job.status !== "running") {
+      throw new Error(`Job must be in running state to execute, got: ${job.status}`);
+    }
+    this.isFirstProgress = true;
+    await this.processHighlightDetectionJob(job);
   }
   /**
-   * Get annotation context (selected text with surrounding context)
+   * Override updateJobProgress to emit events to Event Store
    */
-  static async getAnnotationContext(annotationId2, resourceId2, contextBefore, contextAfter, config) {
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
-    const repStore = new FilesystemRepresentationStore2({ basePath }, projectRoot);
-    const annotation = await this.getAnnotation(annotationId2, resourceId2, config);
-    if (!annotation) {
-      throw new Error("Annotation not found");
+  async updateJobProgress(job) {
+    await super.updateJobProgress(job);
+    if (job.metadata.type !== "highlight-detection") return;
+    if (job.status !== "running") {
+      return;
     }
-    const resource = await ResourceContext.getResourceMetadata(
-      uriToResourceId(getTargetSource(annotation.target)),
-      config
-    );
+    const hlJob = job;
+    const baseEvent = {
+      resourceId: hlJob.params.resourceId,
+      userId: hlJob.metadata.userId,
+      version: 1
+    };
+    const isComplete = hlJob.progress.percentage === 100;
+    if (this.isFirstProgress) {
+      this.isFirstProgress = false;
+      await this.eventStore.appendEvent({
+        type: "job.started",
+        ...baseEvent,
+        payload: {
+          jobId: hlJob.metadata.id,
+          jobType: hlJob.metadata.type
+        }
+      });
+    } else if (isComplete) {
+      await this.eventStore.appendEvent({
+        type: "job.completed",
+        ...baseEvent,
+        payload: {
+          jobId: hlJob.metadata.id,
+          jobType: hlJob.metadata.type
+          // Note: result would come from job.result, but that's handled by base class
+        }
+      });
+    } else {
+      await this.eventStore.appendEvent({
+        type: "job.progress",
+        ...baseEvent,
+        payload: {
+          jobId: hlJob.metadata.id,
+          jobType: hlJob.metadata.type,
+          progress: hlJob.progress
+        }
+      });
+    }
+  }
+  async handleJobFailure(job, error) {
+    await super.handleJobFailure(job, error);
+    if (job.status === "failed" && job.metadata.type === "highlight-detection") {
+      const hlJob = job;
+      await this.eventStore.appendEvent({
+        type: "job.failed",
+        resourceId: hlJob.params.resourceId,
+        userId: hlJob.metadata.userId,
+        version: 1,
+        payload: {
+          jobId: hlJob.metadata.id,
+          jobType: hlJob.metadata.type,
+          error: "Highlight detection failed. Please try again later."
+        }
+      });
+    }
+  }
+  async processHighlightDetectionJob(job) {
+    console.log(`[HighlightDetectionWorker] Processing highlight detection for resource ${job.params.resourceId} (job: ${job.metadata.id})`);
+    const resource = await ResourceContext.getResourceMetadata(job.params.resourceId, this.config);
     if (!resource) {
-      throw new Error("Resource not found");
+      throw new Error(`Resource ${job.params.resourceId} not found`);
     }
-    const contentStr = await this.getResourceContent(resource, repStore);
-    const context = this.extractAnnotationContext(annotation, contentStr, contextBefore, contextAfter);
-    return {
-      annotation,
-      context,
-      resource: {
-        "@context": resource["@context"],
-        "@id": resource["@id"],
-        name: resource.name,
-        entityTypes: resource.entityTypes,
-        representations: resource.representations,
-        archived: resource.archived,
-        creationMethod: resource.creationMethod,
-        wasAttributedTo: resource.wasAttributedTo,
-        dateCreated: resource.dateCreated
+    let updatedJob = {
+      ...job,
+      progress: {
+        stage: "analyzing",
+        percentage: 10,
+        message: "Loading resource..."
       }
     };
-  }
-  /**
-   * Generate AI summary of annotation in context
-   */
-  static async generateAnnotationSummary(annotationId2, resourceId2, config) {
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
-    const repStore = new FilesystemRepresentationStore2({ basePath }, projectRoot);
-    const annotation = await this.getAnnotation(annotationId2, resourceId2, config);
-    if (!annotation) {
-      throw new Error("Annotation not found");
-    }
-    const resource = await ResourceContext.getResourceMetadata(
-      uriToResourceId(getTargetSource(annotation.target)),
-      config
+    await this.updateJobProgress(updatedJob);
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "analyzing",
+        percentage: 30,
+        message: "Analyzing text..."
+      }
+    };
+    await this.updateJobProgress(updatedJob);
+    const highlights = await AnnotationDetection.detectHighlights(
+      job.params.resourceId,
+      this.config,
+      this.inferenceClient,
+      job.params.instructions,
+      job.params.density
     );
-    if (!resource) {
-      throw new Error("Resource not found");
-    }
-    const contentStr = await this.getResourceContent(resource, repStore);
-    const contextSize = 500;
-    const context = this.extractAnnotationContext(annotation, contentStr, contextSize, contextSize);
-    const annotationEntityTypes = getEntityTypes(annotation);
-    const summary = await this.generateSummary(resource, context, annotationEntityTypes, config);
-    return {
-      summary,
-      relevantFields: {
-        resourceId: resource.id,
-        resourceName: resource.name,
-        entityTypes: annotationEntityTypes
-      },
-      context: {
-        before: context.before.substring(Math.max(0, context.before.length - 200)),
-        // Last 200 chars
-        selected: context.selected,
-        after: context.after.substring(0, 200)
-        // First 200 chars
+    console.log(`[HighlightDetectionWorker] Found ${highlights.length} highlights to create`);
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 60,
+        message: `Creating ${highlights.length} annotations...`
       }
     };
-  }
-  /**
-   * Get resource content as string
-   */
-  static async getResourceContent(resource, repStore) {
-    const primaryRep = getPrimaryRepresentation2(resource);
-    if (!primaryRep?.checksum || !primaryRep?.mediaType) {
-      throw new Error("Resource content not found");
-    }
-    const content = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
-    return decodeRepresentation2(content, primaryRep.mediaType);
-  }
-  /**
-   * Extract annotation context from resource content
-   */
-  static extractAnnotationContext(annotation, contentStr, contextBefore, contextAfter) {
-    const targetSelector = getTargetSelector(annotation.target);
-    const posSelector = targetSelector ? getTextPositionSelector(targetSelector) : null;
-    if (!posSelector) {
-      throw new Error("TextPositionSelector required for context");
+    await this.updateJobProgress(updatedJob);
+    let created = 0;
+    for (const highlight of highlights) {
+      try {
+        await this.createHighlightAnnotation(job.params.resourceId, job.metadata.userId, highlight);
+        created++;
+      } catch (error) {
+        console.error(`[HighlightDetectionWorker] Failed to create highlight:`, error);
+      }
     }
-    const selStart = posSelector.start;
-    const selEnd = posSelector.end;
-    const start = Math.max(0, selStart - contextBefore);
-    const end = Math.min(contentStr.length, selEnd + contextAfter);
-    return {
-      before: contentStr.substring(start, selStart),
-      selected: contentStr.substring(selStart, selEnd),
-      after: contentStr.substring(selEnd, end)
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 100,
+        message: `Complete! Created ${created} highlights`
+      }
     };
+    await this.updateJobProgress(updatedJob);
+    console.log(`[HighlightDetectionWorker] \u2705 Created ${created}/${highlights.length} highlights`);
   }
-  /**
-   * Generate LLM summary of annotation in context
-   */
-  static async generateSummary(resource, context, entityTypes, config) {
-    const summaryPrompt = `Summarize this text in context:
-
-Context before: "${context.before.substring(Math.max(0, context.before.length - 200))}"
-Selected exact: "${context.selected}"
-Context after: "${context.after.substring(0, 200)}"
-
-Resource: ${resource.name}
-Entity types: ${entityTypes.join(", ")}`;
-    return await generateText(summaryPrompt, config, 500, 0.5);
+  async createHighlightAnnotation(resourceId2, creatorUserId, highlight) {
+    const backendUrl = this.config.services.backend?.publicURL;
+    if (!backendUrl) throw new Error("Backend publicURL not configured");
+    const annotationId2 = generateAnnotationId2(backendUrl);
+    const resourceUri3 = resourceIdToURI2(resourceId2, backendUrl);
+    const annotation = {
+      "@context": "http://www.w3.org/ns/anno.jsonld",
+      "type": "Annotation",
+      "id": annotationId2,
+      "motivation": "highlighting",
+      "creator": userId(creatorUserId),
+      "created": (/* @__PURE__ */ new Date()).toISOString(),
+      "target": {
+        type: "SpecificResource",
+        source: resourceUri3,
+        selector: [
+          {
+            type: "TextPositionSelector",
+            start: highlight.start,
+            end: highlight.end
+          },
+          {
+            type: "TextQuoteSelector",
+            exact: highlight.exact,
+            ...highlight.prefix && { prefix: highlight.prefix },
+            ...highlight.suffix && { suffix: highlight.suffix }
+          }
+        ]
+      },
+      "body": []
+      // Empty body for highlights
+    };
+    await this.eventStore.appendEvent({
+      type: "annotation.added",
+      resourceId: resourceId2,
+      userId: userId(creatorUserId),
+      version: 1,
+      payload: { annotation }
+    });
   }
 };
 
-// src/graph-context.ts
-import { getGraphDatabase } from "@semiont/graph";
-import { resourceIdToURI } from "@semiont/core";
-var GraphContext = class {
-  /**
-   * Get all resources referencing this resource (backlinks)
-   * Requires graph traversal - must use graph database
-   */
-  static async getBacklinks(resourceId2, config) {
-    const graphDb = await getGraphDatabase(config);
-    const resourceUri2 = resourceIdToURI(resourceId2, config.services.backend.publicURL);
-    return await graphDb.getResourceReferencedBy(resourceUri2);
-  }
-  /**
-   * Find shortest path between two resources
-   * Requires graph traversal - must use graph database
-   */
-  static async findPath(fromResourceId, toResourceId, config, maxDepth) {
-    const graphDb = await getGraphDatabase(config);
-    return await graphDb.findPath(fromResourceId, toResourceId, maxDepth);
+// src/jobs/assessment-detection-worker.ts
+import { JobWorker as JobWorker4 } from "@semiont/jobs";
+import { generateAnnotationId as generateAnnotationId3 } from "@semiont/event-sourcing";
+import { resourceIdToURI as resourceIdToURI3 } from "@semiont/core";
+import { userId as userId2 } from "@semiont/core";
+var AssessmentDetectionWorker = class extends JobWorker4 {
+  constructor(jobQueue, config, eventStore, inferenceClient) {
+    super(jobQueue);
+    this.config = config;
+    this.eventStore = eventStore;
+    this.inferenceClient = inferenceClient;
   }
-  /**
-   * Get resource connections (graph edges)
-   * Requires graph traversal - must use graph database
-   */
-  static async getResourceConnections(resourceId2, config) {
-    const graphDb = await getGraphDatabase(config);
-    return await graphDb.getResourceConnections(resourceId2);
+  isFirstProgress = true;
+  getWorkerName() {
+    return "AssessmentDetectionWorker";
   }
-  /**
-   * Search resources by name (cross-resource query)
-   * Requires full-text search - must use graph database
-   */
-  static async searchResources(query, config, limit) {
-    const graphDb = await getGraphDatabase(config);
-    return await graphDb.searchResources(query, limit);
+  canProcessJob(job) {
+    return job.metadata.type === "assessment-detection";
   }
-};
-
-// src/annotation-detection.ts
-import { FilesystemRepresentationStore as FilesystemRepresentationStore3 } from "@semiont/content";
-import { getPrimaryRepresentation as getPrimaryRepresentation3, decodeRepresentation as decodeRepresentation3 } from "@semiont/api-client";
-import {
-  MotivationPrompts,
-  MotivationParsers,
-  generateText as generateText2
-} from "@semiont/inference";
-import { getTagSchema, getSchemaCategory } from "@semiont/ontology";
-var AnnotationDetection = class {
-  /**
-   * Detect comments in a resource
-   *
-   * @param resourceId - The resource to analyze
-   * @param config - Environment configuration
-   * @param instructions - Optional user instructions for comment generation
-   * @param tone - Optional tone guidance (e.g., "academic", "conversational")
-   * @param density - Optional target number of comments per 2000 words
-   * @returns Array of validated comment matches
-   */
-  static async detectComments(resourceId2, config, instructions, tone, density) {
-    const resource = await ResourceContext.getResourceMetadata(resourceId2, config);
-    if (!resource) {
-      throw new Error(`Resource ${resourceId2} not found`);
+  async executeJob(job) {
+    if (job.metadata.type !== "assessment-detection") {
+      throw new Error(`Invalid job type: ${job.metadata.type}`);
     }
-    const content = await this.loadResourceContent(resourceId2, config);
-    if (!content) {
-      throw new Error(`Could not load content for resource ${resourceId2}`);
+    if (job.status !== "running") {
+      throw new Error(`Job must be in running state to execute, got: ${job.status}`);
     }
-    const prompt = MotivationPrompts.buildCommentPrompt(content, instructions, tone, density);
-    const response = await generateText2(
-      prompt,
-      config,
-      3e3,
-      // maxTokens: Higher than highlights/assessments due to comment text
-      0.4
-      // temperature: Slightly higher to allow creative context
-    );
-    return MotivationParsers.parseComments(response, content);
+    this.isFirstProgress = true;
+    await this.processAssessmentDetectionJob(job);
   }
   /**
-   * Detect highlights in a resource
-   *
-   * @param resourceId - The resource to analyze
-   * @param config - Environment configuration
-   * @param instructions - Optional user instructions for highlight selection
-   * @param density - Optional target number of highlights per 2000 words
-   * @returns Array of validated highlight matches
+   * Override updateJobProgress to emit events to Event Store
    */
-  static async detectHighlights(resourceId2, config, instructions, density) {
-    const resource = await ResourceContext.getResourceMetadata(resourceId2, config);
-    if (!resource) {
-      throw new Error(`Resource ${resourceId2} not found`);
+  async updateJobProgress(job) {
+    await super.updateJobProgress(job);
+    if (job.metadata.type !== "assessment-detection") return;
+    if (job.status !== "running") {
+      return;
     }
-    const content = await this.loadResourceContent(resourceId2, config);
-    if (!content) {
-      throw new Error(`Could not load content for resource ${resourceId2}`);
+    const assJob = job;
+    const baseEvent = {
+      resourceId: assJob.params.resourceId,
+      userId: assJob.metadata.userId,
+      version: 1
+    };
+    const isComplete = assJob.progress.percentage === 100;
+    if (this.isFirstProgress) {
+      this.isFirstProgress = false;
+      await this.eventStore.appendEvent({
+        type: "job.started",
+        ...baseEvent,
+        payload: {
+          jobId: assJob.metadata.id,
+          jobType: assJob.metadata.type
+        }
+      });
+    } else if (isComplete) {
+      await this.eventStore.appendEvent({
+        type: "job.completed",
+        ...baseEvent,
+        payload: {
+          jobId: assJob.metadata.id,
+          jobType: assJob.metadata.type
+          // Note: result would come from job.result, but that's handled by base class
+        }
+      });
+    } else {
+      await this.eventStore.appendEvent({
+        type: "job.progress",
+        ...baseEvent,
+        payload: {
+          jobId: assJob.metadata.id,
+          jobType: assJob.metadata.type,
+          progress: assJob.progress
+        }
+      });
     }
-    const prompt = MotivationPrompts.buildHighlightPrompt(content, instructions, density);
-    const response = await generateText2(
-      prompt,
-      config,
-      2e3,
-      // maxTokens: Lower than comments/assessments (no body text)
-      0.3
-      // temperature: Low for consistent importance judgments
-    );
-    return MotivationParsers.parseHighlights(response, content);
   }
-  /**
-   * Detect assessments in a resource
-   *
-   * @param resourceId - The resource to analyze
-   * @param config - Environment configuration
-   * @param instructions - Optional user instructions for assessment generation
-   * @param tone - Optional tone guidance (e.g., "critical", "supportive")
-   * @param density - Optional target number of assessments per 2000 words
-   * @returns Array of validated assessment matches
-   */
-  static async detectAssessments(resourceId2, config, instructions, tone, density) {
-    const resource = await ResourceContext.getResourceMetadata(resourceId2, config);
-    if (!resource) {
-      throw new Error(`Resource ${resourceId2} not found`);
-    }
-    const content = await this.loadResourceContent(resourceId2, config);
-    if (!content) {
-      throw new Error(`Could not load content for resource ${resourceId2}`);
+  async handleJobFailure(job, error) {
+    await super.handleJobFailure(job, error);
+    if (job.status === "failed" && job.metadata.type === "assessment-detection") {
+      const aJob = job;
+      await this.eventStore.appendEvent({
+        type: "job.failed",
+        resourceId: aJob.params.resourceId,
+        userId: aJob.metadata.userId,
+        version: 1,
+        payload: {
+          jobId: aJob.metadata.id,
+          jobType: aJob.metadata.type,
+          error: "Assessment detection failed. Please try again later."
+        }
+      });
     }
-    const prompt = MotivationPrompts.buildAssessmentPrompt(content, instructions, tone, density);
-    const response = await generateText2(
-      prompt,
-      config,
-      3e3,
-      // maxTokens: Higher for assessment text
-      0.3
-      // temperature: Lower for analytical consistency
-    );
-    return MotivationParsers.parseAssessments(response, content);
   }
-  /**
-   * Detect tags in a resource for a specific category
-   *
-   * @param resourceId - The resource to analyze
-   * @param config - Environment configuration
-   * @param schemaId - The tag schema identifier (e.g., "irac", "imrad")
-   * @param category - The specific category to detect
-   * @returns Array of validated tag matches
-   */
-  static async detectTags(resourceId2, config, schemaId, category) {
-    const schema = getTagSchema(schemaId);
-    if (!schema) {
-      throw new Error(`Invalid tag schema: ${schemaId}`);
-    }
-    const categoryInfo = getSchemaCategory(schemaId, category);
-    if (!categoryInfo) {
-      throw new Error(`Invalid category "${category}" for schema ${schemaId}`);
-    }
-    const resource = await ResourceContext.getResourceMetadata(resourceId2, config);
+  async processAssessmentDetectionJob(job) {
+    console.log(`[AssessmentDetectionWorker] Processing assessment detection for resource ${job.params.resourceId} (job: ${job.metadata.id})`);
+    const resource = await ResourceContext.getResourceMetadata(job.params.resourceId, this.config);
     if (!resource) {
-      throw new Error(`Resource ${resourceId2} not found`);
-    }
-    const content = await this.loadResourceContent(resourceId2, config);
-    if (!content) {
-      throw new Error(`Could not load content for resource ${resourceId2}`);
+      throw new Error(`Resource ${job.params.resourceId} not found`);
     }
-    const prompt = MotivationPrompts.buildTagPrompt(
-      content,
-      category,
-      schema.name,
-      schema.description,
-      schema.domain,
-      categoryInfo.description,
-      categoryInfo.examples
-    );
-    const response = await generateText2(
-      prompt,
-      config,
-      4e3,
-      // maxTokens: Higher for full document analysis
-      0.2
-      // temperature: Lower for structural consistency
+    let updatedJob = {
+      ...job,
+      progress: {
+        stage: "analyzing",
+        percentage: 10,
+        message: "Loading resource..."
+      }
+    };
+    await this.updateJobProgress(updatedJob);
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "analyzing",
+        percentage: 30,
+        message: "Analyzing text..."
+      }
+    };
+    await this.updateJobProgress(updatedJob);
+    const assessments = await AnnotationDetection.detectAssessments(
+      job.params.resourceId,
+      this.config,
+      this.inferenceClient,
+      job.params.instructions,
+      job.params.tone,
+      job.params.density
     );
-    const parsedTags = MotivationParsers.parseTags(response);
-    return MotivationParsers.validateTagOffsets(parsedTags, content, category);
-  }
-  /**
-   * Load resource content from representation store
-   * Helper method used by all detection methods
-   *
-   * @param resourceId - The resource ID to load
-   * @param config - Environment configuration
-   * @returns Resource content as string, or null if not available
-   */
-  static async loadResourceContent(resourceId2, config) {
-    const resource = await ResourceContext.getResourceMetadata(resourceId2, config);
-    if (!resource) return null;
-    const primaryRep = getPrimaryRepresentation3(resource);
-    if (!primaryRep) return null;
-    const baseMediaType = primaryRep.mediaType?.split(";")[0]?.trim() || "";
-    if (baseMediaType !== "text/plain" && baseMediaType !== "text/markdown") {
-      return null;
+    console.log(`[AssessmentDetectionWorker] Found ${assessments.length} assessments to create`);
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 60,
+        message: `Creating ${assessments.length} annotations...`
+      }
+    };
+    await this.updateJobProgress(updatedJob);
+    let created = 0;
+    for (const assessment of assessments) {
+      try {
+        await this.createAssessmentAnnotation(job.params.resourceId, job.metadata.userId, assessment);
+        created++;
+      } catch (error) {
+        console.error(`[AssessmentDetectionWorker] Failed to create assessment:`, error);
+      }
     }
-    if (!primaryRep.checksum || !primaryRep.mediaType) return null;
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
-    const repStore = new FilesystemRepresentationStore3({ basePath }, projectRoot);
-    const contentBuffer = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
-    return decodeRepresentation3(contentBuffer, primaryRep.mediaType);
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 100,
+        message: `Complete! Created ${created} assessments`
+      }
+    };
+    await this.updateJobProgress(updatedJob);
+    console.log(`[AssessmentDetectionWorker] \u2705 Created ${created}/${assessments.length} assessments`);
+  }
+  async createAssessmentAnnotation(resourceId2, creatorUserId, assessment) {
+    const backendUrl = this.config.services.backend?.publicURL;
+    if (!backendUrl) throw new Error("Backend publicURL not configured");
+    const annotationId2 = generateAnnotationId3(backendUrl);
+    const resourceUri3 = resourceIdToURI3(resourceId2, backendUrl);
+    const annotation = {
+      "@context": "http://www.w3.org/ns/anno.jsonld",
+      "type": "Annotation",
+      "id": annotationId2,
+      "motivation": "assessing",
+      "creator": userId2(creatorUserId),
+      "created": (/* @__PURE__ */ new Date()).toISOString(),
+      "target": {
+        type: "SpecificResource",
+        source: resourceUri3,
+        selector: [
+          {
+            type: "TextPositionSelector",
+            start: assessment.start,
+            end: assessment.end
+          },
+          {
+            type: "TextQuoteSelector",
+            exact: assessment.exact,
+            ...assessment.prefix && { prefix: assessment.prefix },
+            ...assessment.suffix && { suffix: assessment.suffix }
+          }
+        ]
+      },
+      "body": {
+        type: "TextualBody",
+        value: assessment.assessment,
+        format: "text/plain"
+      }
+    };
+    await this.eventStore.appendEvent({
+      type: "annotation.added",
+      resourceId: resourceId2,
+      userId: userId2(creatorUserId),
+      version: 1,
+      payload: { annotation }
+    });
   }
 };
 
-// src/jobs/workers/comment-detection-worker.ts
-import { JobWorker } from "@semiont/jobs";
-import { generateAnnotationId } from "@semiont/event-sourcing";
-import { resourceIdToURI as resourceIdToURI2 } from "@semiont/core";
-import { userId } from "@semiont/core";
-var CommentDetectionWorker = class extends JobWorker {
-  constructor(jobQueue, config, eventStore) {
+// src/jobs/comment-detection-worker.ts
+import { JobWorker as JobWorker5 } from "@semiont/jobs";
+import { generateAnnotationId as generateAnnotationId4 } from "@semiont/event-sourcing";
+import { resourceIdToURI as resourceIdToURI4 } from "@semiont/core";
+import { userId as userId3 } from "@semiont/core";
+var CommentDetectionWorker = class extends JobWorker5 {
+  constructor(jobQueue, config, eventStore, inferenceClient) {
     super(jobQueue);
     this.config = config;
     this.eventStore = eventStore;
+    this.inferenceClient = inferenceClient;
   }
   isFirstProgress = true;
   getWorkerName() {
     return "CommentDetectionWorker";
   }
   canProcessJob(job) {
-    return job.type === "comment-detection";
+    return job.metadata.type === "comment-detection";
   }
   async executeJob(job) {
-    if (job.type !== "comment-detection") {
-      throw new Error(`Invalid job type: ${job.type}`);
+    if (job.metadata.type !== "comment-detection") {
+      throw new Error(`Invalid job type: ${job.metadata.type}`);
+    }
+    if (job.status !== "running") {
+      throw new Error(`Job must be in running state to execute, got: ${job.status}`);
     }
     this.isFirstProgress = true;
     await this.processCommentDetectionJob(job);
@@ -731,23 +1234,25 @@ var CommentDetectionWorker = class extends JobWorker {
    */
   async updateJobProgress(job) {
     await super.updateJobProgress(job);
-    if (job.type !== "comment-detection") return;
+    if (job.metadata.type !== "comment-detection") return;
+    if (job.status !== "running") {
+      return;
+    }
     const cdJob = job;
-    if (!cdJob.progress) return;
     const baseEvent = {
-      resourceId: cdJob.resourceId,
-      userId: cdJob.userId,
+      resourceId: cdJob.params.resourceId,
+      userId: cdJob.metadata.userId,
       version: 1
     };
-    const isComplete = cdJob.progress.percentage === 100 && cdJob.result;
+    const isComplete = cdJob.progress.percentage === 100;
     if (this.isFirstProgress) {
       this.isFirstProgress = false;
       await this.eventStore.appendEvent({
         type: "job.started",
         ...baseEvent,
         payload: {
-          jobId: cdJob.id,
-          jobType: cdJob.type
+          jobId: cdJob.metadata.id,
+          jobType: cdJob.metadata.type
         }
       });
     } else if (isComplete) {
@@ -755,9 +1260,9 @@ var CommentDetectionWorker = class extends JobWorker {
         type: "job.completed",
         ...baseEvent,
         payload: {
-          jobId: cdJob.id,
-          jobType: cdJob.type,
-          result: cdJob.result
+          jobId: cdJob.metadata.id,
+          jobType: cdJob.metadata.type
+          // Note: result would come from job.result, but that's handled by base class
         }
       });
     } else {
@@ -765,8 +1270,8 @@ var CommentDetectionWorker = class extends JobWorker {
         type: "job.progress",
         ...baseEvent,
         payload: {
-          jobId: cdJob.id,
-          jobType: cdJob.type,
+          jobId: cdJob.metadata.id,
+          jobType: cdJob.metadata.type,
           progress: cdJob.progress
         }
       });
@@ -774,72 +1279,81 @@ var CommentDetectionWorker = class extends JobWorker {
   }
   async handleJobFailure(job, error) {
     await super.handleJobFailure(job, error);
-    if (job.status === "failed" && job.type === "comment-detection") {
+    if (job.status === "failed" && job.metadata.type === "comment-detection") {
       const cdJob = job;
       await this.eventStore.appendEvent({
         type: "job.failed",
-        resourceId: cdJob.resourceId,
-        userId: cdJob.userId,
+        resourceId: cdJob.params.resourceId,
+        userId: cdJob.metadata.userId,
         version: 1,
         payload: {
-          jobId: cdJob.id,
-          jobType: cdJob.type,
+          jobId: cdJob.metadata.id,
+          jobType: cdJob.metadata.type,
           error: "Comment detection failed. Please try again later."
         }
       });
     }
   }
   async processCommentDetectionJob(job) {
-    console.log(`[CommentDetectionWorker] Processing comment detection for resource ${job.resourceId} (job: ${job.id})`);
-    const resource = await ResourceContext.getResourceMetadata(job.resourceId, this.config);
+    console.log(`[CommentDetectionWorker] Processing comment detection for resource ${job.params.resourceId} (job: ${job.metadata.id})`);
+    const resource = await ResourceContext.getResourceMetadata(job.params.resourceId, this.config);
     if (!resource) {
-      throw new Error(`Resource ${job.resourceId} not found`);
+      throw new Error(`Resource ${job.params.resourceId} not found`);
     }
-    job.progress = {
-      stage: "analyzing",
-      percentage: 10,
-      message: "Loading resource..."
+    let updatedJob = {
+      ...job,
+      progress: {
+        stage: "analyzing",
+        percentage: 10,
+        message: "Loading resource..."
+      }
     };
-    await this.updateJobProgress(job);
-    job.progress = {
-      stage: "analyzing",
-      percentage: 30,
-      message: "Analyzing text and generating comments..."
+    await this.updateJobProgress(updatedJob);
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "analyzing",
+        percentage: 30,
+        message: "Analyzing text and generating comments..."
+      }
     };
-    await this.updateJobProgress(job);
+    await this.updateJobProgress(updatedJob);
     const comments = await AnnotationDetection.detectComments(
-      job.resourceId,
+      job.params.resourceId,
       this.config,
-      job.instructions,
-      job.tone,
-      job.density
+      this.inferenceClient,
+      job.params.instructions,
+      job.params.tone,
+      job.params.density
     );
     console.log(`[CommentDetectionWorker] Found ${comments.length} comments to create`);
-    job.progress = {
-      stage: "creating",
-      percentage: 60,
-      message: `Creating ${comments.length} annotations...`
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 60,
+        message: `Creating ${comments.length} annotations...`
+      }
     };
-    await this.updateJobProgress(job);
+    await this.updateJobProgress(updatedJob);
     let created = 0;
     for (const comment of comments) {
       try {
-        await this.createCommentAnnotation(job.resourceId, job.userId, comment);
+        await this.createCommentAnnotation(job.params.resourceId, job.metadata.userId, comment);
         created++;
       } catch (error) {
         console.error(`[CommentDetectionWorker] Failed to create comment:`, error);
       }
     }
-    job.result = {
-      commentsFound: comments.length,
-      commentsCreated: created
-    };
-    job.progress = {
-      stage: "creating",
-      percentage: 100,
-      message: `Complete! Created ${created} comments`
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 100,
+        message: `Complete! Created ${created} comments`
+      }
     };
-    await this.updateJobProgress(job);
+    await this.updateJobProgress(updatedJob);
     console.log(`[CommentDetectionWorker] \u2705 Created ${created}/${comments.length} comments`);
   }
   async createCommentAnnotation(resourceId2, userId_, comment) {
@@ -847,8 +1361,8 @@ var CommentDetectionWorker = class extends JobWorker {
     if (!backendUrl) {
       throw new Error("Backend publicURL not configured");
     }
-    const resourceUri2 = resourceIdToURI2(resourceId2, backendUrl);
-    const annotationId2 = generateAnnotationId(backendUrl);
+    const resourceUri3 = resourceIdToURI4(resourceId2, backendUrl);
+    const annotationId2 = generateAnnotationId4(backendUrl);
     const annotation = {
       "@context": "http://www.w3.org/ns/anno.jsonld",
       type: "Annotation",
@@ -856,7 +1370,7 @@ var CommentDetectionWorker = class extends JobWorker {
       motivation: "commenting",
       target: {
         type: "SpecificResource",
-        source: resourceUri2,
+        source: resourceUri3,
         selector: [
           {
             type: "TextPositionSelector",
@@ -884,7 +1398,7 @@ var CommentDetectionWorker = class extends JobWorker {
     await this.eventStore.appendEvent({
       type: "annotation.added",
       resourceId: resourceId2,
-      userId: userId(userId_),
+      userId: userId3(userId_),
       version: 1,
       payload: {
         annotation
@@ -894,53 +1408,60 @@ var CommentDetectionWorker = class extends JobWorker {
   }
 };
 
-// src/jobs/workers/highlight-detection-worker.ts
-import { JobWorker as JobWorker2 } from "@semiont/jobs";
-import { generateAnnotationId as generateAnnotationId2 } from "@semiont/event-sourcing";
-import { resourceIdToURI as resourceIdToURI3 } from "@semiont/core";
-import { userId as userId2 } from "@semiont/core";
-var HighlightDetectionWorker = class extends JobWorker2 {
-  constructor(jobQueue, config, eventStore) {
+// src/jobs/tag-detection-worker.ts
+import { JobWorker as JobWorker6 } from "@semiont/jobs";
+import { generateAnnotationId as generateAnnotationId5 } from "@semiont/event-sourcing";
+import { resourceIdToURI as resourceIdToURI5 } from "@semiont/core";
+import { getTagSchema } from "@semiont/ontology";
+import { userId as userId4 } from "@semiont/core";
+var TagDetectionWorker = class extends JobWorker6 {
+  constructor(jobQueue, config, eventStore, inferenceClient) {
     super(jobQueue);
     this.config = config;
     this.eventStore = eventStore;
+    this.inferenceClient = inferenceClient;
   }
   isFirstProgress = true;
   getWorkerName() {
-    return "HighlightDetectionWorker";
+    return "TagDetectionWorker";
   }
   canProcessJob(job) {
-    return job.type === "highlight-detection";
+    return job.metadata.type === "tag-detection";
   }
   async executeJob(job) {
-    if (job.type !== "highlight-detection") {
-      throw new Error(`Invalid job type: ${job.type}`);
+    if (job.metadata.type !== "tag-detection") {
+      throw new Error(`Invalid job type: ${job.metadata.type}`);
+    }
+    if (job.status !== "running") {
+      throw new Error(`Job must be in running state to execute, got: ${job.status}`);
     }
     this.isFirstProgress = true;
-    await this.processHighlightDetectionJob(job);
+    await this.processTagDetectionJob(job);
   }
   /**
    * Override updateJobProgress to emit events to Event Store
    */
   async updateJobProgress(job) {
     await super.updateJobProgress(job);
-    if (job.type !== "highlight-detection") return;
-    const hlJob = job;
-    if (!hlJob.progress) return;
+    if (job.metadata.type !== "tag-detection") return;
+    if (job.status !== "running") {
+      return;
+    }
+    const tdJob = job;
     const baseEvent = {
-      resourceId: hlJob.resourceId,
-      userId: hlJob.userId,
+      resourceId: tdJob.params.resourceId,
+      userId: tdJob.metadata.userId,
       version: 1
     };
-    const isComplete = hlJob.progress.percentage === 100 && hlJob.result;
+    const isComplete = tdJob.progress.percentage === 100;
     if (this.isFirstProgress) {
       this.isFirstProgress = false;
       await this.eventStore.appendEvent({
         type: "job.started",
         ...baseEvent,
         payload: {
-          jobId: hlJob.id,
-          jobType: hlJob.type
+          jobId: tdJob.metadata.id,
+          jobType: tdJob.metadata.type
         }
       });
     } else if (isComplete) {
@@ -948,9 +1469,9 @@ var HighlightDetectionWorker = class extends JobWorker2 {
         type: "job.completed",
         ...baseEvent,
         payload: {
-          jobId: hlJob.id,
-          jobType: hlJob.type,
-          result: hlJob.result
+          jobId: tdJob.metadata.id,
+          jobType: tdJob.metadata.type
+          // Note: result would come from job.result, but that's handled by base class
         }
       });
     } else {
@@ -958,1020 +1479,1804 @@ var HighlightDetectionWorker = class extends JobWorker2 {
         type: "job.progress",
         ...baseEvent,
         payload: {
-          jobId: hlJob.id,
-          jobType: hlJob.type,
-          progress: hlJob.progress
+          jobId: tdJob.metadata.id,
+          jobType: tdJob.metadata.type,
+          progress: tdJob.progress
         }
       });
     }
   }
   async handleJobFailure(job, error) {
     await super.handleJobFailure(job, error);
-    if (job.status === "failed" && job.type === "highlight-detection") {
-      const hlJob = job;
+    if (job.status === "failed" && job.metadata.type === "tag-detection") {
+      const tdJob = job;
       await this.eventStore.appendEvent({
         type: "job.failed",
-        resourceId: hlJob.resourceId,
-        userId: hlJob.userId,
+        resourceId: tdJob.params.resourceId,
+        userId: tdJob.metadata.userId,
         version: 1,
         payload: {
-          jobId: hlJob.id,
-          jobType: hlJob.type,
-          error: "Highlight detection failed. Please try again later."
+          jobId: tdJob.metadata.id,
+          jobType: tdJob.metadata.type,
+          error: "Tag detection failed. Please try again later."
         }
       });
     }
   }
-  async processHighlightDetectionJob(job) {
-    console.log(`[HighlightDetectionWorker] Processing highlight detection for resource ${job.resourceId} (job: ${job.id})`);
-    const resource = await ResourceContext.getResourceMetadata(job.resourceId, this.config);
+  async processTagDetectionJob(job) {
+    console.log(`[TagDetectionWorker] Processing tag detection for resource ${job.params.resourceId} (job: ${job.metadata.id})`);
+    const schema = getTagSchema(job.params.schemaId);
+    if (!schema) {
+      throw new Error(`Invalid tag schema: ${job.params.schemaId}`);
+    }
+    for (const category of job.params.categories) {
+      if (!schema.tags.some((t) => t.name === category)) {
+        throw new Error(`Invalid category "${category}" for schema ${job.params.schemaId}`);
+      }
+    }
+    const resource = await ResourceContext.getResourceMetadata(job.params.resourceId, this.config);
     if (!resource) {
-      throw new Error(`Resource ${job.resourceId} not found`);
+      throw new Error(`Resource ${job.params.resourceId} not found`);
     }
-    job.progress = {
-      stage: "analyzing",
-      percentage: 10,
-      message: "Loading resource..."
-    };
-    await this.updateJobProgress(job);
-    job.progress = {
-      stage: "analyzing",
-      percentage: 30,
-      message: "Analyzing text..."
+    let updatedJob = {
+      ...job,
+      progress: {
+        stage: "analyzing",
+        percentage: 10,
+        processedCategories: 0,
+        totalCategories: job.params.categories.length,
+        message: "Loading resource..."
+      }
     };
-    await this.updateJobProgress(job);
-    const highlights = await AnnotationDetection.detectHighlights(
-      job.resourceId,
-      this.config,
-      job.instructions,
-      job.density
-    );
-    console.log(`[HighlightDetectionWorker] Found ${highlights.length} highlights to create`);
-    job.progress = {
-      stage: "creating",
-      percentage: 60,
-      message: `Creating ${highlights.length} annotations...`
+    await this.updateJobProgress(updatedJob);
+    const allTags = [];
+    const byCategory = {};
+    for (let i = 0; i < job.params.categories.length; i++) {
+      const category = job.params.categories[i];
+      updatedJob = {
+        ...updatedJob,
+        progress: {
+          stage: "analyzing",
+          percentage: 10 + Math.floor(i / job.params.categories.length * 50),
+          currentCategory: category,
+          processedCategories: i + 1,
+          totalCategories: job.params.categories.length,
+          message: `Analyzing ${category}...`
+        }
+      };
+      await this.updateJobProgress(updatedJob);
+      const tags = await AnnotationDetection.detectTags(
+        job.params.resourceId,
+        this.config,
+        this.inferenceClient,
+        job.params.schemaId,
+        category
+      );
+      console.log(`[TagDetectionWorker] Found ${tags.length} tags for category "${category}"`);
+      allTags.push(...tags);
+      byCategory[category] = tags.length;
+    }
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 60,
+        processedCategories: job.params.categories.length,
+        totalCategories: job.params.categories.length,
+        message: `Creating ${allTags.length} tag annotations...`
+      }
     };
-    await this.updateJobProgress(job);
+    await this.updateJobProgress(updatedJob);
     let created = 0;
-    for (const highlight of highlights) {
+    for (const tag of allTags) {
       try {
-        await this.createHighlightAnnotation(job.resourceId, job.userId, highlight);
+        await this.createTagAnnotation(job.params.resourceId, job.metadata.userId, job.params.schemaId, tag);
         created++;
       } catch (error) {
-        console.error(`[HighlightDetectionWorker] Failed to create highlight:`, error);
+        console.error(`[TagDetectionWorker] Failed to create tag:`, error);
       }
     }
-    job.result = {
-      highlightsFound: highlights.length,
-      highlightsCreated: created
-    };
-    job.progress = {
-      stage: "creating",
-      percentage: 100,
-      message: `Complete! Created ${created} highlights`
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 100,
+        processedCategories: job.params.categories.length,
+        totalCategories: job.params.categories.length,
+        message: `Complete! Created ${created} tags`
+      }
     };
-    await this.updateJobProgress(job);
-    console.log(`[HighlightDetectionWorker] \u2705 Created ${created}/${highlights.length} highlights`);
+    await this.updateJobProgress(updatedJob);
+    console.log(`[TagDetectionWorker] \u2705 Created ${created}/${allTags.length} tags across ${job.params.categories.length} categories`);
   }
-  async createHighlightAnnotation(resourceId2, creatorUserId, highlight) {
+  async createTagAnnotation(resourceId2, userId_, schemaId, tag) {
     const backendUrl = this.config.services.backend?.publicURL;
-    if (!backendUrl) throw new Error("Backend publicURL not configured");
-    const annotationId2 = generateAnnotationId2(backendUrl);
-    const resourceUri2 = resourceIdToURI3(resourceId2, backendUrl);
+    if (!backendUrl) {
+      throw new Error("Backend publicURL not configured");
+    }
+    const resourceUri3 = resourceIdToURI5(resourceId2, backendUrl);
+    const annotationId2 = generateAnnotationId5(backendUrl);
     const annotation = {
       "@context": "http://www.w3.org/ns/anno.jsonld",
-      "type": "Annotation",
-      "id": annotationId2,
-      "motivation": "highlighting",
-      "creator": userId2(creatorUserId),
-      "created": (/* @__PURE__ */ new Date()).toISOString(),
-      "target": {
+      type: "Annotation",
+      id: annotationId2,
+      motivation: "tagging",
+      target: {
         type: "SpecificResource",
-        source: resourceUri2,
+        source: resourceUri3,
         selector: [
           {
             type: "TextPositionSelector",
-            start: highlight.start,
-            end: highlight.end
+            start: tag.start,
+            end: tag.end
           },
           {
             type: "TextQuoteSelector",
-            exact: highlight.exact,
-            ...highlight.prefix && { prefix: highlight.prefix },
-            ...highlight.suffix && { suffix: highlight.suffix }
+            exact: tag.exact,
+            prefix: tag.prefix || "",
+            suffix: tag.suffix || ""
           }
         ]
       },
-      "body": []
-      // Empty body for highlights
-    };
-    await this.eventStore.appendEvent({
-      type: "annotation.added",
-      resourceId: resourceId2,
-      userId: userId2(creatorUserId),
-      version: 1,
-      payload: { annotation }
-    });
-  }
-};
+      body: [
+        {
+          type: "TextualBody",
+          value: tag.category,
+          purpose: "tagging",
+          format: "text/plain",
+          language: "en"
+        },
+        {
+          type: "TextualBody",
+          value: schemaId,
+          purpose: "classifying",
+          format: "text/plain"
+        }
+      ]
+    };
+    await this.eventStore.appendEvent({
+      type: "annotation.added",
+      resourceId: resourceId2,
+      userId: userId4(userId_),
+      version: 1,
+      payload: {
+        annotation
+      }
+    });
+    console.log(`[TagDetectionWorker] Created tag annotation ${annotationId2} for "${tag.category}": "${tag.exact.substring(0, 50)}..."`);
+  }
+};
 
-// src/jobs/workers/assessment-detection-worker.ts
-import { JobWorker as JobWorker3 } from "@semiont/jobs";
-import { generateAnnotationId as generateAnnotationId3 } from "@semiont/event-sourcing";
-import { resourceIdToURI as resourceIdToURI4 } from "@semiont/core";
-import { userId as userId3 } from "@semiont/core";
-var AssessmentDetectionWorker = class extends JobWorker3 {
-  constructor(jobQueue, config, eventStore) {
-    super(jobQueue);
+// src/graph/consumer.ts
+import { EventQuery } from "@semiont/event-sourcing";
+import { didToAgent } from "@semiont/core";
+import { resourceId as makeResourceId, findBodyItem } from "@semiont/core";
+import { toResourceUri, toAnnotationUri } from "@semiont/event-sourcing";
+import { resourceUri as resourceUri2 } from "@semiont/api-client";
+var GraphDBConsumer = class {
+  constructor(config, eventStore, graphDb) {
     this.config = config;
     this.eventStore = eventStore;
+    this.graphDb = graphDb;
   }
-  isFirstProgress = true;
-  getWorkerName() {
-    return "AssessmentDetectionWorker";
+  subscriptions = /* @__PURE__ */ new Map();
+  _globalSubscription = null;
+  // Subscription to system-level events (kept for cleanup)
+  processing = /* @__PURE__ */ new Map();
+  lastProcessed = /* @__PURE__ */ new Map();
+  async initialize() {
+    console.log("[GraphDBConsumer] Initialized");
+    await this.subscribeToGlobalEvents();
   }
-  canProcessJob(job) {
-    return job.type === "assessment-detection";
+  /**
+   * Subscribe to global system-level events (no resourceId)
+   * This allows the consumer to react to events like entitytype.added
+   */
+  async subscribeToGlobalEvents() {
+    this._globalSubscription = this.eventStore.bus.subscriptions.subscribeGlobal(async (storedEvent) => {
+      console.log(`[GraphDBConsumer] Received global event: ${storedEvent.event.type}`);
+      await this.processEvent(storedEvent);
+    });
+    console.log("[GraphDBConsumer] Subscribed to global system events");
   }
-  async executeJob(job) {
-    if (job.type !== "assessment-detection") {
-      throw new Error(`Invalid job type: ${job.type}`);
+  ensureInitialized() {
+    return this.graphDb;
+  }
+  /**
+   * Subscribe to events for a resource
+   * Apply each event to GraphDB
+   */
+  async subscribeToResource(resourceId2) {
+    this.ensureInitialized();
+    const publicURL = this.config.services.backend.publicURL;
+    const rUri = resourceUri2(`${publicURL}/resources/${resourceId2}`);
+    const subscription = this.eventStore.bus.subscriptions.subscribe(rUri, async (storedEvent) => {
+      await this.processEvent(storedEvent);
+    });
+    this.subscriptions.set(resourceId2, subscription);
+    console.log(`[GraphDBConsumer] Subscribed to ${resourceId2}`);
+  }
+  /**
+   * Stop the consumer and unsubscribe from all events
+   */
+  async stop() {
+    console.log("[GraphDBConsumer] Stopping...");
+    for (const subscription of this.subscriptions.values()) {
+      if (subscription && typeof subscription.unsubscribe === "function") {
+        subscription.unsubscribe();
+      }
+    }
+    this.subscriptions.clear();
+    if (this._globalSubscription && typeof this._globalSubscription.unsubscribe === "function") {
+      this._globalSubscription.unsubscribe();
+    }
+    this._globalSubscription = null;
+    console.log("[GraphDBConsumer] Stopped");
+  }
+  /**
+   * Process event with ordering guarantee (sequential per resource)
+   */
+  async processEvent(storedEvent) {
+    const { resourceId: resourceId2 } = storedEvent.event;
+    if (!resourceId2) {
+      await this.applyEventToGraph(storedEvent);
+      return;
+    }
+    const previousProcessing = this.processing.get(resourceId2);
+    if (previousProcessing) {
+      await previousProcessing;
+    }
+    const processingPromise = this.applyEventToGraph(storedEvent);
+    this.processing.set(resourceId2, processingPromise);
+    try {
+      await processingPromise;
+      this.lastProcessed.set(resourceId2, storedEvent.metadata.sequenceNumber);
+    } catch (error) {
+      console.error(`[GraphDBConsumer] Failed to process event:`, error);
+      throw error;
+    } finally {
+      this.processing.delete(resourceId2);
+    }
+  }
+  /**
+   * Apply event to GraphDB
+   */
+  async applyEventToGraph(storedEvent) {
+    const graphDb = this.ensureInitialized();
+    const event = storedEvent.event;
+    console.log(`[GraphDBConsumer] Applying ${event.type} to GraphDB (seq=${storedEvent.metadata.sequenceNumber})`);
+    switch (event.type) {
+      case "resource.created": {
+        if (!event.resourceId) throw new Error("resource.created requires resourceId");
+        const resourceUri3 = toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId);
+        const resource = {
+          "@context": "https://schema.org/",
+          "@id": resourceUri3,
+          name: event.payload.name,
+          entityTypes: event.payload.entityTypes || [],
+          representations: [{
+            mediaType: event.payload.format,
+            checksum: event.payload.contentChecksum,
+            rel: "original"
+          }],
+          archived: false,
+          dateCreated: (/* @__PURE__ */ new Date()).toISOString(),
+          wasAttributedTo: didToAgent(event.userId),
+          creationMethod: "api"
+        };
+        console.log(`[GraphDBConsumer] Creating resource in graph: ${resourceUri3}`);
+        await graphDb.createResource(resource);
+        console.log(`[GraphDBConsumer] \u2705 Resource created in graph: ${resourceUri3}`);
+        break;
+      }
+      case "resource.cloned": {
+        if (!event.resourceId) throw new Error("resource.cloned requires resourceId");
+        const resourceUri3 = toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId);
+        const resource = {
+          "@context": "https://schema.org/",
+          "@id": resourceUri3,
+          name: event.payload.name,
+          entityTypes: event.payload.entityTypes || [],
+          representations: [{
+            mediaType: event.payload.format,
+            checksum: event.payload.contentChecksum,
+            rel: "original"
+          }],
+          archived: false,
+          dateCreated: (/* @__PURE__ */ new Date()).toISOString(),
+          wasAttributedTo: didToAgent(event.userId),
+          creationMethod: "clone"
+        };
+        console.log(`[GraphDBConsumer] Creating cloned resource in graph: ${resourceUri3}`);
+        await graphDb.createResource(resource);
+        console.log(`[GraphDBConsumer] \u2705 Cloned resource created in graph: ${resourceUri3}`);
+        break;
+      }
+      case "resource.archived":
+        if (!event.resourceId) throw new Error("resource.archived requires resourceId");
+        await graphDb.updateResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId), {
+          archived: true
+        });
+        break;
+      case "resource.unarchived":
+        if (!event.resourceId) throw new Error("resource.unarchived requires resourceId");
+        await graphDb.updateResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId), {
+          archived: false
+        });
+        break;
+      case "annotation.added":
+        console.log(`[GraphDBConsumer] \u{1F50D} ENTERED annotation.added case block`);
+        console.log(`[GraphDBConsumer] Annotation ID: ${event.payload.annotation.id}`);
+        await graphDb.createAnnotation({
+          ...event.payload.annotation,
+          creator: didToAgent(event.userId)
+        });
+        console.log(`[GraphDBConsumer] \u2705 Annotation created in graph: ${event.payload.annotation.id}`);
+        break;
+      case "annotation.removed":
+        await graphDb.deleteAnnotation(toAnnotationUri({ baseUrl: this.config.services.backend.publicURL }, event.payload.annotationId));
+        break;
+      case "annotation.body.updated":
+        console.log(`[GraphDBConsumer] \u{1F50D} ENTERED annotation.body.updated case block`);
+        console.log(`[GraphDBConsumer] Event payload:`, JSON.stringify(event.payload));
+        try {
+          console.log(`[GraphDBConsumer] Creating annotation URI for: ${event.payload.annotationId}`);
+          const annotationUri2 = toAnnotationUri({ baseUrl: this.config.services.backend.publicURL }, event.payload.annotationId);
+          console.log(`[GraphDBConsumer] \u2705 Annotation URI created: ${annotationUri2}`);
+          console.log(`[GraphDBConsumer] Processing annotation.body.updated for ${annotationUri2}`);
+          console.log(`[GraphDBConsumer] Operations:`, JSON.stringify(event.payload.operations));
+          const currentAnnotation = await graphDb.getAnnotation(annotationUri2);
+          console.log(`[GraphDBConsumer] Current annotation in graph:`, currentAnnotation ? "FOUND" : "NOT FOUND");
+          if (currentAnnotation) {
+            console.log(`[GraphDBConsumer] Current body:`, JSON.stringify(currentAnnotation.body));
+            let bodyArray = Array.isArray(currentAnnotation.body) ? [...currentAnnotation.body] : currentAnnotation.body ? [currentAnnotation.body] : [];
+            for (const op of event.payload.operations) {
+              console.log(`[GraphDBConsumer] Applying operation:`, JSON.stringify(op));
+              if (op.op === "add") {
+                const exists = findBodyItem(bodyArray, op.item) !== -1;
+                if (!exists) {
+                  bodyArray.push(op.item);
+                  console.log(`[GraphDBConsumer] Added item to body`);
+                } else {
+                  console.log(`[GraphDBConsumer] Item already exists, skipping`);
+                }
+              } else if (op.op === "remove") {
+                const index = findBodyItem(bodyArray, op.item);
+                if (index !== -1) {
+                  bodyArray.splice(index, 1);
+                  console.log(`[GraphDBConsumer] Removed item from body`);
+                }
+              } else if (op.op === "replace") {
+                const index = findBodyItem(bodyArray, op.oldItem);
+                if (index !== -1) {
+                  bodyArray[index] = op.newItem;
+                  console.log(`[GraphDBConsumer] Replaced item in body`);
+                }
+              }
+            }
+            console.log(`[GraphDBConsumer] New body array:`, JSON.stringify(bodyArray));
+            console.log(`[GraphDBConsumer] Calling updateAnnotation...`);
+            await graphDb.updateAnnotation(annotationUri2, {
+              body: bodyArray
+            });
+            console.log(`[GraphDBConsumer] \u2705 updateAnnotation completed successfully`);
+          } else {
+            console.log(`[GraphDBConsumer] \u26A0\uFE0F  Annotation not found in graph, skipping update`);
+          }
+        } catch (error) {
+          console.error(`[GraphDBConsumer] \u274C ERROR in annotation.body.updated handler`);
+          console.error(`[GraphDBConsumer] Annotation ID: ${event.payload.annotationId}`);
+          console.error(`[GraphDBConsumer] Error:`, error);
+          console.error(`[GraphDBConsumer] Error stack:`, error instanceof Error ? error.stack : "N/A");
+        }
+        break;
+      case "entitytag.added":
+        if (!event.resourceId) throw new Error("entitytag.added requires resourceId");
+        const doc = await graphDb.getResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId));
+        if (doc) {
+          await graphDb.updateResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId), {
+            entityTypes: [...doc.entityTypes || [], event.payload.entityType]
+          });
+        }
+        break;
+      case "entitytag.removed":
+        if (!event.resourceId) throw new Error("entitytag.removed requires resourceId");
+        const doc2 = await graphDb.getResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId));
+        if (doc2) {
+          await graphDb.updateResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId), {
+            entityTypes: (doc2.entityTypes || []).filter((t) => t !== event.payload.entityType)
+          });
+        }
+        break;
+      case "entitytype.added":
+        await graphDb.addEntityType(event.payload.entityType);
+        break;
+      default:
+        console.warn(`[GraphDBConsumer] Unknown event type: ${event.type}`);
+    }
+  }
+  /**
+   * Rebuild entire resource from events
+   * Useful for recovery or initial sync
+   */
+  async rebuildResource(resourceId2) {
+    const graphDb = this.ensureInitialized();
+    console.log(`[GraphDBConsumer] Rebuilding resource ${resourceId2} from events`);
+    try {
+      await graphDb.deleteResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, makeResourceId(resourceId2)));
+    } catch (error) {
+      console.log(`[GraphDBConsumer] No existing resource to delete: ${resourceId2}`);
+    }
+    const query = new EventQuery(this.eventStore.log.storage);
+    const events = await query.getResourceEvents(resourceId2);
+    for (const storedEvent of events) {
+      await this.applyEventToGraph(storedEvent);
+    }
+    console.log(`[GraphDBConsumer] Rebuilt ${resourceId2} from ${events.length} events`);
+  }
+  /**
+   * Rebuild entire GraphDB from all events
+   * Uses two-pass approach to ensure all resources exist before creating REFERENCES edges
+   */
+  async rebuildAll() {
+    const graphDb = this.ensureInitialized();
+    console.log("[GraphDBConsumer] Rebuilding entire GraphDB from events...");
+    console.log("[GraphDBConsumer] Using two-pass approach: nodes first, then edges\n");
+    await graphDb.clearDatabase();
+    const query = new EventQuery(this.eventStore.log.storage);
+    const allResourceIds = await this.eventStore.log.getAllResourceIds();
+    console.log(`[GraphDBConsumer] Found ${allResourceIds.length} resources to rebuild`);
+    console.log("\n[GraphDBConsumer] === PASS 1: Creating all nodes (resources + annotations) ===");
+    for (const resourceId2 of allResourceIds) {
+      const events = await query.getResourceEvents(makeResourceId(resourceId2));
+      for (const storedEvent of events) {
+        if (storedEvent.event.type === "annotation.body.updated") {
+          continue;
+        }
+        await this.applyEventToGraph(storedEvent);
+      }
+    }
+    console.log("[GraphDBConsumer] \u2705 Pass 1 complete - all nodes created\n");
+    console.log("[GraphDBConsumer] === PASS 2: Creating all REFERENCES edges ===");
+    for (const resourceId2 of allResourceIds) {
+      const events = await query.getResourceEvents(makeResourceId(resourceId2));
+      for (const storedEvent of events) {
+        if (storedEvent.event.type === "annotation.body.updated") {
+          await this.applyEventToGraph(storedEvent);
+        }
+      }
+    }
+    console.log("[GraphDBConsumer] \u2705 Pass 2 complete - all edges created\n");
+    console.log("[GraphDBConsumer] Rebuild complete");
+  }
+  /**
+   * Get consumer health metrics
+   */
+  getHealthMetrics() {
+    return {
+      subscriptions: this.subscriptions.size,
+      lastProcessed: Object.fromEntries(this.lastProcessed),
+      processing: Array.from(this.processing.keys())
+    };
+  }
+  /**
+   * Unsubscribe from resource
+   */
+  async unsubscribeFromResource(resourceId2) {
+    const subscription = this.subscriptions.get(resourceId2);
+    if (subscription) {
+      subscription.unsubscribe();
+      this.subscriptions.delete(resourceId2);
+      console.log(`[GraphDBConsumer] Unsubscribed from ${resourceId2}`);
+    }
+  }
+  /**
+   * Unsubscribe from all resources
+   */
+  async unsubscribeAll() {
+    for (const [_resourceId, subscription] of this.subscriptions) {
+      subscription.unsubscribe();
+    }
+    this.subscriptions.clear();
+    console.log("[GraphDBConsumer] Unsubscribed from all resources");
+  }
+  /**
+   * Shutdown consumer
+   */
+  async shutdown() {
+    await this.unsubscribeAll();
+    if (this._globalSubscription) {
+      this._globalSubscription.unsubscribe();
+      this._globalSubscription = null;
+      console.log("[GraphDBConsumer] Unsubscribed from global events");
+    }
+    console.log("[GraphDBConsumer] Shut down");
+  }
+};
+
+// src/service.ts
+async function startMakeMeaning(config) {
+  console.log("\u{1F9E0} Starting Make-Meaning service...");
+  const configuredPath = config.services?.filesystem?.path;
+  if (!configuredPath) {
+    throw new Error("services.filesystem.path is required for make-meaning service");
+  }
+  const baseUrl = config.services?.backend?.publicURL;
+  if (!baseUrl) {
+    throw new Error("services.backend.publicURL is required for make-meaning service");
+  }
+  const projectRoot = config._metadata?.projectRoot;
+  let basePath;
+  if (path.isAbsolute(configuredPath)) {
+    basePath = configuredPath;
+  } else if (projectRoot) {
+    basePath = path.resolve(projectRoot, configuredPath);
+  } else {
+    basePath = path.resolve(configuredPath);
+  }
+  console.log("\u{1F4BC} Initializing job queue...");
+  const jobQueue = new JobQueue({ dataDir: basePath });
+  await jobQueue.initialize();
+  console.log("\u2705 Job queue initialized");
+  console.log("\u{1F4CA} Creating event store connection...");
+  const eventStore = createEventStoreCore(basePath, baseUrl);
+  console.log("\u{1F4E6} Creating representation store...");
+  const repStore = new FilesystemRepresentationStore3({ basePath }, projectRoot);
+  console.log("\u2705 Representation store created");
+  console.log("\u{1F916} Creating inference client...");
+  const inferenceClient = await getInferenceClient(config);
+  console.log("\u2705 Inference client created");
+  console.log("\u{1F4CA} Connecting to graph database...");
+  const graphDb = await getGraphDatabase(config);
+  console.log("\u2705 Graph database connected");
+  console.log("\u{1F504} Starting graph consumer...");
+  const graphConsumer = new GraphDBConsumer(config, eventStore, graphDb);
+  await graphConsumer.initialize();
+  const allResourceIds = await eventStore.log.getAllResourceIds();
+  console.log(`[GraphDBConsumer] Subscribing to ${allResourceIds.length} resources`);
+  for (const resourceId2 of allResourceIds) {
+    await graphConsumer.subscribeToResource(makeResourceId2(resourceId2));
+  }
+  console.log("\u2705 Graph consumer started");
+  console.log("\u{1F477} Creating workers...");
+  const workers = {
+    detection: new ReferenceDetectionWorker(jobQueue, config, eventStore, inferenceClient),
+    generation: new GenerationWorker(jobQueue, config, eventStore, inferenceClient),
+    highlight: new HighlightDetectionWorker(jobQueue, config, eventStore, inferenceClient),
+    assessment: new AssessmentDetectionWorker(jobQueue, config, eventStore, inferenceClient),
+    comment: new CommentDetectionWorker(jobQueue, config, eventStore, inferenceClient),
+    tag: new TagDetectionWorker(jobQueue, config, eventStore, inferenceClient)
+  };
+  console.log("\u{1F680} Starting workers...");
+  workers.detection.start().catch((error) => {
+    console.error("\u26A0\uFE0F Detection worker stopped:", error);
+  });
+  workers.generation.start().catch((error) => {
+    console.error("\u26A0\uFE0F Generation worker stopped:", error);
+  });
+  workers.highlight.start().catch((error) => {
+    console.error("\u26A0\uFE0F Highlight worker stopped:", error);
+  });
+  workers.assessment.start().catch((error) => {
+    console.error("\u26A0\uFE0F Assessment worker stopped:", error);
+  });
+  workers.comment.start().catch((error) => {
+    console.error("\u26A0\uFE0F Comment worker stopped:", error);
+  });
+  workers.tag.start().catch((error) => {
+    console.error("\u26A0\uFE0F Tag worker stopped:", error);
+  });
+  console.log("\u2705 All workers started");
+  console.log("\u2705 Make-Meaning service started");
+  return {
+    jobQueue,
+    eventStore,
+    repStore,
+    inferenceClient,
+    graphDb,
+    workers,
+    graphConsumer,
+    stop: async () => {
+      console.log("\u23F9\uFE0F Stopping Make-Meaning service...");
+      await Promise.all([
+        workers.detection.stop(),
+        workers.generation.stop(),
+        workers.highlight.stop(),
+        workers.assessment.stop(),
+        workers.comment.stop(),
+        workers.tag.stop()
+      ]);
+      await graphConsumer.stop();
+      await graphDb.disconnect();
+      console.log("\u2705 Make-Meaning service stopped");
+    }
+  };
+}
+
+// src/resource-context.ts
+import { FilesystemViewStorage } from "@semiont/event-sourcing";
+import { FilesystemRepresentationStore as FilesystemRepresentationStore4 } from "@semiont/content";
+import { getPrimaryRepresentation as getPrimaryRepresentation2, decodeRepresentation as decodeRepresentation2 } from "@semiont/api-client";
+var ResourceContext = class {
+  /**
+   * Get resource metadata from view storage
+   */
+  static async getResourceMetadata(resourceId2, config) {
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const viewStorage = new FilesystemViewStorage(basePath, projectRoot);
+    const view = await viewStorage.get(resourceId2);
+    if (!view) {
+      return null;
+    }
+    return view.resource;
+  }
+  /**
+   * List all resources by scanning view storage
+   */
+  static async listResources(filters, config) {
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const viewStorage = new FilesystemViewStorage(basePath, projectRoot);
+    const allViews = await viewStorage.getAll();
+    const resources = [];
+    for (const view of allViews) {
+      const doc = view.resource;
+      if (filters?.archived !== void 0 && doc.archived !== filters.archived) {
+        continue;
+      }
+      if (filters?.search) {
+        const searchLower = filters.search.toLowerCase();
+        if (!doc.name.toLowerCase().includes(searchLower)) {
+          continue;
+        }
+      }
+      resources.push(doc);
+    }
+    resources.sort((a, b) => {
+      const aTime = a.dateCreated ? new Date(a.dateCreated).getTime() : 0;
+      const bTime = b.dateCreated ? new Date(b.dateCreated).getTime() : 0;
+      return bTime - aTime;
+    });
+    return resources;
+  }
+  /**
+   * Add content previews to resources (for search results)
+   * Retrieves and decodes the first 200 characters of each resource's primary representation
+   */
+  static async addContentPreviews(resources, config) {
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const repStore = new FilesystemRepresentationStore4({ basePath }, projectRoot);
+    return await Promise.all(
+      resources.map(async (doc) => {
+        try {
+          const primaryRep = getPrimaryRepresentation2(doc);
+          if (primaryRep?.checksum && primaryRep?.mediaType) {
+            const contentBuffer = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
+            const contentPreview = decodeRepresentation2(contentBuffer, primaryRep.mediaType).slice(0, 200);
+            return { ...doc, content: contentPreview };
+          }
+          return { ...doc, content: "" };
+        } catch {
+          return { ...doc, content: "" };
+        }
+      })
+    );
+  }
+};
+
+// src/annotation-context.ts
+import { getInferenceClient as getInferenceClient2 } from "@semiont/inference";
+import {
+  getBodySource,
+  getTargetSource,
+  getTargetSelector as getTargetSelector2,
+  getResourceEntityTypes,
+  getTextPositionSelector,
+  getPrimaryRepresentation as getPrimaryRepresentation3,
+  decodeRepresentation as decodeRepresentation3
+} from "@semiont/api-client";
+import { FilesystemRepresentationStore as FilesystemRepresentationStore5 } from "@semiont/content";
+import { FilesystemViewStorage as FilesystemViewStorage2 } from "@semiont/event-sourcing";
+import { resourceId as createResourceId, uriToResourceId } from "@semiont/core";
+import { getEntityTypes as getEntityTypes2 } from "@semiont/ontology";
+var AnnotationContext = class {
+  /**
+   * Build LLM context for an annotation
+   *
+   * @param annotationUri - Full annotation URI (e.g., http://localhost:4000/annotations/abc123)
+   * @param resourceId - Source resource ID
+   * @param config - Application configuration
+   * @param options - Context building options
+   * @returns Rich context for LLM processing
+   * @throws Error if annotation or resource not found
+   */
+  static async buildLLMContext(annotationUri2, resourceId2, config, options = {}) {
+    const {
+      includeSourceContext = true,
+      includeTargetContext = true,
+      contextWindow = 1e3
+    } = options;
+    if (contextWindow < 100 || contextWindow > 5e3) {
+      throw new Error("contextWindow must be between 100 and 5000");
+    }
+    console.log(`[AnnotationContext] buildLLMContext called with annotationUri=${annotationUri2}, resourceId=${resourceId2}`);
+    const basePath = config.services.filesystem.path;
+    console.log(`[AnnotationContext] basePath=${basePath}`);
+    const projectRoot = config._metadata?.projectRoot;
+    const viewStorage = new FilesystemViewStorage2(basePath, projectRoot);
+    const repStore = new FilesystemRepresentationStore5({ basePath }, projectRoot);
+    console.log(`[AnnotationContext] Getting view for resourceId=${resourceId2}`);
+    let sourceView;
+    try {
+      sourceView = await viewStorage.get(resourceId2);
+      console.log(`[AnnotationContext] Got view:`, !!sourceView);
+      if (!sourceView) {
+        throw new Error("Source resource not found");
+      }
+    } catch (error) {
+      console.error(`[AnnotationContext] Error getting view:`, error);
+      throw error;
+    }
+    console.log(`[AnnotationContext] Looking for annotation ${annotationUri2} in resource ${resourceId2}`);
+    console.log(`[AnnotationContext] View has ${sourceView.annotations.annotations.length} annotations`);
+    console.log(`[AnnotationContext] First 5 annotation IDs:`, sourceView.annotations.annotations.slice(0, 5).map((a) => a.id));
+    const annotation = sourceView.annotations.annotations.find((a) => a.id === annotationUri2);
+    console.log(`[AnnotationContext] Found annotation:`, !!annotation);
+    if (!annotation) {
+      throw new Error("Annotation not found in view");
+    }
+    const targetSource = getTargetSource(annotation.target);
+    const targetResourceId = targetSource.split("/").pop();
+    console.log(`[AnnotationContext] Target source: ${targetSource}, Expected resource ID: ${resourceId2}, Extracted ID: ${targetResourceId}`);
+    if (targetResourceId !== resourceId2) {
+      throw new Error(`Annotation target resource ID (${targetResourceId}) does not match expected resource ID (${resourceId2})`);
+    }
+    const sourceDoc = sourceView.resource;
+    const bodySource = getBodySource(annotation.body);
+    let targetDoc = null;
+    if (bodySource) {
+      const parts = bodySource.split("/");
+      const lastPart = parts[parts.length - 1];
+      if (!lastPart) {
+        throw new Error(`Invalid body source URI: ${bodySource}`);
+      }
+      const targetResourceId2 = createResourceId(lastPart);
+      const targetView = await viewStorage.get(targetResourceId2);
+      targetDoc = targetView?.resource || null;
+    }
+    let sourceContext;
+    if (includeSourceContext) {
+      const primaryRep = getPrimaryRepresentation3(sourceDoc);
+      if (!primaryRep?.checksum || !primaryRep?.mediaType) {
+        throw new Error("Source content not found");
+      }
+      const sourceContent = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
+      const contentStr = decodeRepresentation3(sourceContent, primaryRep.mediaType);
+      const targetSelectorRaw = getTargetSelector2(annotation.target);
+      const targetSelector = Array.isArray(targetSelectorRaw) ? targetSelectorRaw[0] : targetSelectorRaw;
+      console.log(`[AnnotationContext] Target selector type:`, targetSelector?.type);
+      if (!targetSelector) {
+        console.warn(`[AnnotationContext] No target selector found`);
+      } else if (targetSelector.type === "TextPositionSelector") {
+        const selector = targetSelector;
+        const start = selector.start;
+        const end = selector.end;
+        const before = contentStr.slice(Math.max(0, start - contextWindow), start);
+        const selected = contentStr.slice(start, end);
+        const after = contentStr.slice(end, Math.min(contentStr.length, end + contextWindow));
+        sourceContext = { before, selected, after };
+        console.log(`[AnnotationContext] Built source context using TextPositionSelector (${start}-${end})`);
+      } else if (targetSelector.type === "TextQuoteSelector") {
+        const selector = targetSelector;
+        const exact = selector.exact;
+        const index = contentStr.indexOf(exact);
+        if (index !== -1) {
+          const start = index;
+          const end = index + exact.length;
+          const before = contentStr.slice(Math.max(0, start - contextWindow), start);
+          const selected = exact;
+          const after = contentStr.slice(end, Math.min(contentStr.length, end + contextWindow));
+          sourceContext = { before, selected, after };
+          console.log(`[AnnotationContext] Built source context using TextQuoteSelector (found at ${index})`);
+        } else {
+          console.warn(`[AnnotationContext] TextQuoteSelector exact text not found in content: "${exact.substring(0, 50)}..."`);
+        }
+      } else {
+        console.warn(`[AnnotationContext] Unknown selector type: ${targetSelector.type}`);
+      }
+    }
+    let targetContext;
+    if (includeTargetContext && targetDoc) {
+      const targetRep = getPrimaryRepresentation3(targetDoc);
+      if (targetRep?.checksum && targetRep?.mediaType) {
+        const targetContent = await repStore.retrieve(targetRep.checksum, targetRep.mediaType);
+        const contentStr = decodeRepresentation3(targetContent, targetRep.mediaType);
+        const client = await getInferenceClient2(config);
+        targetContext = {
+          content: contentStr.slice(0, contextWindow * 2),
+          summary: await generateResourceSummary(targetDoc.name, contentStr, getResourceEntityTypes(targetDoc), client)
+        };
+      }
+    }
+    const suggestedResolution = void 0;
+    const generationContext = sourceContext ? {
+      sourceContext: {
+        before: sourceContext.before || "",
+        selected: sourceContext.selected,
+        after: sourceContext.after || ""
+      },
+      metadata: {
+        resourceType: "document",
+        language: sourceDoc.language,
+        entityTypes: getEntityTypes2(annotation)
+      }
+    } : void 0;
+    const response = {
+      annotation,
+      sourceResource: sourceDoc,
+      targetResource: targetDoc,
+      ...generationContext ? { context: generationContext } : {},
+      ...sourceContext ? { sourceContext } : {},
+      // Keep for backward compatibility
+      ...targetContext ? { targetContext } : {},
+      ...suggestedResolution ? { suggestedResolution } : {}
+    };
+    return response;
+  }
+  /**
+   * Get resource annotations from view storage (fast path)
+   * Throws if view missing
+   */
+  static async getResourceAnnotations(resourceId2, config) {
+    if (!config.services?.filesystem?.path) {
+      throw new Error("Filesystem path not found in configuration");
     }
-    this.isFirstProgress = true;
-    await this.processAssessmentDetectionJob(job);
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const viewStorage = new FilesystemViewStorage2(basePath, projectRoot);
+    const view = await viewStorage.get(resourceId2);
+    if (!view) {
+      throw new Error(`Resource ${resourceId2} not found in view storage`);
+    }
+    return view.annotations;
   }
   /**
-   * Override updateJobProgress to emit events to Event Store
+   * Get all annotations
+   * @returns Array of all annotation objects
    */
-  async updateJobProgress(job) {
-    await super.updateJobProgress(job);
-    if (job.type !== "assessment-detection") return;
-    const assJob = job;
-    if (!assJob.progress) return;
-    const baseEvent = {
-      resourceId: assJob.resourceId,
-      userId: assJob.userId,
-      version: 1
-    };
-    const isComplete = assJob.progress.percentage === 100 && assJob.result;
-    if (this.isFirstProgress) {
-      this.isFirstProgress = false;
-      await this.eventStore.appendEvent({
-        type: "job.started",
-        ...baseEvent,
-        payload: {
-          jobId: assJob.id,
-          jobType: assJob.type
-        }
-      });
-    } else if (isComplete) {
-      await this.eventStore.appendEvent({
-        type: "job.completed",
-        ...baseEvent,
-        payload: {
-          jobId: assJob.id,
-          jobType: assJob.type,
-          result: assJob.result
-        }
-      });
-    } else {
-      await this.eventStore.appendEvent({
-        type: "job.progress",
-        ...baseEvent,
-        payload: {
-          jobId: assJob.id,
-          jobType: assJob.type,
-          progress: assJob.progress
-        }
-      });
-    }
+  static async getAllAnnotations(resourceId2, config) {
+    const annotations = await this.getResourceAnnotations(resourceId2, config);
+    return await this.enrichResolvedReferences(annotations.annotations, config);
   }
-  async handleJobFailure(job, error) {
-    await super.handleJobFailure(job, error);
-    if (job.status === "failed" && job.type === "assessment-detection") {
-      const aJob = job;
-      await this.eventStore.appendEvent({
-        type: "job.failed",
-        resourceId: aJob.resourceId,
-        userId: aJob.userId,
-        version: 1,
-        payload: {
-          jobId: aJob.id,
-          jobType: aJob.type,
-          error: "Assessment detection failed. Please try again later."
+  /**
+   * Enrich reference annotations with resolved document names
+   * Adds _resolvedDocumentName property to annotations that link to documents
+   * @private
+   */
+  static async enrichResolvedReferences(annotations, config) {
+    if (!config.services?.filesystem?.path) {
+      return annotations;
+    }
+    const resolvedUris = /* @__PURE__ */ new Set();
+    for (const ann of annotations) {
+      if (ann.motivation === "linking" && ann.body) {
+        const body = Array.isArray(ann.body) ? ann.body : [ann.body];
+        for (const item of body) {
+          if (item.type === "SpecificResource" && item.purpose === "linking" && item.source) {
+            resolvedUris.add(item.source);
+          }
         }
-      });
+      }
     }
-  }
-  async processAssessmentDetectionJob(job) {
-    console.log(`[AssessmentDetectionWorker] Processing assessment detection for resource ${job.resourceId} (job: ${job.id})`);
-    const resource = await ResourceContext.getResourceMetadata(job.resourceId, this.config);
-    if (!resource) {
-      throw new Error(`Resource ${job.resourceId} not found`);
+    if (resolvedUris.size === 0) {
+      return annotations;
     }
-    job.progress = {
-      stage: "analyzing",
-      percentage: 10,
-      message: "Loading resource..."
-    };
-    await this.updateJobProgress(job);
-    job.progress = {
-      stage: "analyzing",
-      percentage: 30,
-      message: "Analyzing text..."
-    };
-    await this.updateJobProgress(job);
-    const assessments = await AnnotationDetection.detectAssessments(
-      job.resourceId,
-      this.config,
-      job.instructions,
-      job.tone,
-      job.density
-    );
-    console.log(`[AssessmentDetectionWorker] Found ${assessments.length} assessments to create`);
-    job.progress = {
-      stage: "creating",
-      percentage: 60,
-      message: `Creating ${assessments.length} annotations...`
-    };
-    await this.updateJobProgress(job);
-    let created = 0;
-    for (const assessment of assessments) {
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const viewStorage = new FilesystemViewStorage2(basePath, projectRoot);
+    const metadataPromises = Array.from(resolvedUris).map(async (uri) => {
+      const docId = uri.split("/resources/")[1];
+      if (!docId) return null;
       try {
-        await this.createAssessmentAnnotation(job.resourceId, job.userId, assessment);
-        created++;
-      } catch (error) {
-        console.error(`[AssessmentDetectionWorker] Failed to create assessment:`, error);
+        const view = await viewStorage.get(docId);
+        if (view?.resource?.name) {
+          return {
+            uri,
+            metadata: {
+              name: view.resource.name,
+              mediaType: view.resource.mediaType
+            }
+          };
+        }
+      } catch (e) {
+      }
+      return null;
+    });
+    const results = await Promise.all(metadataPromises);
+    const uriToMetadata = /* @__PURE__ */ new Map();
+    for (const result of results) {
+      if (result) {
+        uriToMetadata.set(result.uri, result.metadata);
       }
     }
-    job.result = {
-      assessmentsFound: assessments.length,
-      assessmentsCreated: created
-    };
-    job.progress = {
-      stage: "creating",
-      percentage: 100,
-      message: `Complete! Created ${created} assessments`
-    };
-    await this.updateJobProgress(job);
-    console.log(`[AssessmentDetectionWorker] \u2705 Created ${created}/${assessments.length} assessments`);
-  }
-  async createAssessmentAnnotation(resourceId2, creatorUserId, assessment) {
-    const backendUrl = this.config.services.backend?.publicURL;
-    if (!backendUrl) throw new Error("Backend publicURL not configured");
-    const annotationId2 = generateAnnotationId3(backendUrl);
-    const resourceUri2 = resourceIdToURI4(resourceId2, backendUrl);
-    const annotation = {
-      "@context": "http://www.w3.org/ns/anno.jsonld",
-      "type": "Annotation",
-      "id": annotationId2,
-      "motivation": "assessing",
-      "creator": userId3(creatorUserId),
-      "created": (/* @__PURE__ */ new Date()).toISOString(),
-      "target": {
-        type: "SpecificResource",
-        source: resourceUri2,
-        selector: [
-          {
-            type: "TextPositionSelector",
-            start: assessment.start,
-            end: assessment.end
-          },
-          {
-            type: "TextQuoteSelector",
-            exact: assessment.exact,
-            ...assessment.prefix && { prefix: assessment.prefix },
-            ...assessment.suffix && { suffix: assessment.suffix }
+    return annotations.map((ann) => {
+      if (ann.motivation === "linking" && ann.body) {
+        const body = Array.isArray(ann.body) ? ann.body : [ann.body];
+        for (const item of body) {
+          if (item.type === "SpecificResource" && item.purpose === "linking" && item.source) {
+            const metadata = uriToMetadata.get(item.source);
+            if (metadata) {
+              return {
+                ...ann,
+                _resolvedDocumentName: metadata.name,
+                _resolvedDocumentMediaType: metadata.mediaType
+              };
+            }
           }
-        ]
-      },
-      "body": {
-        type: "TextualBody",
-        value: assessment.assessment,
-        format: "text/plain"
+        }
       }
-    };
-    await this.eventStore.appendEvent({
-      type: "annotation.added",
-      resourceId: resourceId2,
-      userId: userId3(creatorUserId),
-      version: 1,
-      payload: { annotation }
+      return ann;
     });
   }
-};
-
-// src/jobs/workers/tag-detection-worker.ts
-import { JobWorker as JobWorker4 } from "@semiont/jobs";
-import { generateAnnotationId as generateAnnotationId4 } from "@semiont/event-sourcing";
-import { resourceIdToURI as resourceIdToURI5 } from "@semiont/core";
-import { getTagSchema as getTagSchema2 } from "@semiont/ontology";
-import { userId as userId4 } from "@semiont/core";
-var TagDetectionWorker = class extends JobWorker4 {
-  constructor(jobQueue, config, eventStore) {
-    super(jobQueue);
-    this.config = config;
-    this.eventStore = eventStore;
-  }
-  isFirstProgress = true;
-  getWorkerName() {
-    return "TagDetectionWorker";
-  }
-  canProcessJob(job) {
-    return job.type === "tag-detection";
+  /**
+   * Get resource stats (version info)
+   * @returns Version and timestamp info for the annotations
+   */
+  static async getResourceStats(resourceId2, config) {
+    const annotations = await this.getResourceAnnotations(resourceId2, config);
+    return {
+      resourceId: annotations.resourceId,
+      version: annotations.version,
+      updatedAt: annotations.updatedAt
+    };
   }
-  async executeJob(job) {
-    if (job.type !== "tag-detection") {
-      throw new Error(`Invalid job type: ${job.type}`);
+  /**
+   * Check if resource exists in view storage
+   */
+  static async resourceExists(resourceId2, config) {
+    if (!config.services?.filesystem?.path) {
+      throw new Error("Filesystem path not found in configuration");
     }
-    this.isFirstProgress = true;
-    await this.processTagDetectionJob(job);
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const viewStorage = new FilesystemViewStorage2(basePath, projectRoot);
+    return await viewStorage.exists(resourceId2);
   }
   /**
-   * Override updateJobProgress to emit events to Event Store
+   * Get a single annotation by ID
+   * O(1) lookup using resource ID to access view storage
    */
-  async updateJobProgress(job) {
-    await super.updateJobProgress(job);
-    if (job.type !== "tag-detection") return;
-    const tdJob = job;
-    if (!tdJob.progress) return;
-    const baseEvent = {
-      resourceId: tdJob.resourceId,
-      userId: tdJob.userId,
-      version: 1
-    };
-    const isComplete = tdJob.progress.percentage === 100 && tdJob.result;
-    if (this.isFirstProgress) {
-      this.isFirstProgress = false;
-      await this.eventStore.appendEvent({
-        type: "job.started",
-        ...baseEvent,
-        payload: {
-          jobId: tdJob.id,
-          jobType: tdJob.type
-        }
-      });
-    } else if (isComplete) {
-      await this.eventStore.appendEvent({
-        type: "job.completed",
-        ...baseEvent,
-        payload: {
-          jobId: tdJob.id,
-          jobType: tdJob.type,
-          result: tdJob.result
-        }
-      });
-    } else {
-      await this.eventStore.appendEvent({
-        type: "job.progress",
-        ...baseEvent,
-        payload: {
-          jobId: tdJob.id,
-          jobType: tdJob.type,
-          progress: tdJob.progress
-        }
-      });
+  static async getAnnotation(annotationId2, resourceId2, config) {
+    const annotations = await this.getResourceAnnotations(resourceId2, config);
+    return annotations.annotations.find((a) => {
+      const shortId = a.id.split("/").pop();
+      return shortId === annotationId2;
+    }) || null;
+  }
+  /**
+   * List annotations with optional filtering
+   * @param filters - Optional filters like resourceId and type
+   * @throws Error if resourceId not provided (cross-resource queries not supported in view storage)
+   */
+  static async listAnnotations(filters, config) {
+    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, config);
   }
-  async handleJobFailure(job, error) {
-    await super.handleJobFailure(job, error);
-    if (job.status === "failed" && job.type === "tag-detection") {
-      const tdJob = job;
-      await this.eventStore.appendEvent({
-        type: "job.failed",
-        resourceId: tdJob.resourceId,
-        userId: tdJob.userId,
-        version: 1,
-        payload: {
-          jobId: tdJob.id,
-          jobType: tdJob.type,
-          error: "Tag detection failed. Please try again later."
-        }
-      });
+  /**
+   * Get annotation context (selected text with surrounding context)
+   */
+  static async getAnnotationContext(annotationId2, resourceId2, contextBefore, contextAfter, config) {
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const repStore = new FilesystemRepresentationStore5({ basePath }, projectRoot);
+    const annotation = await this.getAnnotation(annotationId2, resourceId2, config);
+    if (!annotation) {
+      throw new Error("Annotation not found");
     }
-  }
-  async processTagDetectionJob(job) {
-    console.log(`[TagDetectionWorker] Processing tag detection for resource ${job.resourceId} (job: ${job.id})`);
-    const schema = getTagSchema2(job.schemaId);
-    if (!schema) {
-      throw new Error(`Invalid tag schema: ${job.schemaId}`);
+    const resource = await ResourceContext.getResourceMetadata(
+      uriToResourceId(getTargetSource(annotation.target)),
+      config
+    );
+    if (!resource) {
+      throw new Error("Resource not found");
     }
-    for (const category of job.categories) {
-      if (!schema.tags.some((t) => t.name === category)) {
-        throw new Error(`Invalid category "${category}" for schema ${job.schemaId}`);
+    const contentStr = await this.getResourceContent(resource, repStore);
+    const context = this.extractAnnotationContext(annotation, contentStr, contextBefore, contextAfter);
+    return {
+      annotation,
+      context,
+      resource: {
+        "@context": resource["@context"],
+        "@id": resource["@id"],
+        name: resource.name,
+        entityTypes: resource.entityTypes,
+        representations: resource.representations,
+        archived: resource.archived,
+        creationMethod: resource.creationMethod,
+        wasAttributedTo: resource.wasAttributedTo,
+        dateCreated: resource.dateCreated
       }
+    };
+  }
+  /**
+   * Generate AI summary of annotation in context
+   */
+  static async generateAnnotationSummary(annotationId2, resourceId2, config) {
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const repStore = new FilesystemRepresentationStore5({ basePath }, projectRoot);
+    const annotation = await this.getAnnotation(annotationId2, resourceId2, config);
+    if (!annotation) {
+      throw new Error("Annotation not found");
     }
-    const resource = await ResourceContext.getResourceMetadata(job.resourceId, this.config);
+    const resource = await ResourceContext.getResourceMetadata(
+      uriToResourceId(getTargetSource(annotation.target)),
+      config
+    );
     if (!resource) {
-      throw new Error(`Resource ${job.resourceId} not found`);
-    }
-    job.progress = {
-      stage: "analyzing",
-      percentage: 10,
-      processedCategories: 0,
-      totalCategories: job.categories.length,
-      message: "Loading resource..."
-    };
-    await this.updateJobProgress(job);
-    const allTags = [];
-    const byCategory = {};
-    for (let i = 0; i < job.categories.length; i++) {
-      const category = job.categories[i];
-      job.progress = {
-        stage: "analyzing",
-        percentage: 10 + Math.floor(i / job.categories.length * 50),
-        currentCategory: category,
-        processedCategories: i + 1,
-        totalCategories: job.categories.length,
-        message: `Analyzing ${category}...`
-      };
-      await this.updateJobProgress(job);
-      const tags = await AnnotationDetection.detectTags(
-        job.resourceId,
-        this.config,
-        job.schemaId,
-        category
-      );
-      console.log(`[TagDetectionWorker] Found ${tags.length} tags for category "${category}"`);
-      allTags.push(...tags);
-      byCategory[category] = tags.length;
+      throw new Error("Resource not found");
     }
-    job.progress = {
-      stage: "creating",
-      percentage: 60,
-      processedCategories: job.categories.length,
-      totalCategories: job.categories.length,
-      message: `Creating ${allTags.length} tag annotations...`
-    };
-    await this.updateJobProgress(job);
-    let created = 0;
-    for (const tag of allTags) {
-      try {
-        await this.createTagAnnotation(job.resourceId, job.userId, job.schemaId, tag);
-        created++;
-      } catch (error) {
-        console.error(`[TagDetectionWorker] Failed to create tag:`, error);
+    const contentStr = await this.getResourceContent(resource, repStore);
+    const contextSize = 500;
+    const context = this.extractAnnotationContext(annotation, contentStr, contextSize, contextSize);
+    const annotationEntityTypes = getEntityTypes2(annotation);
+    const summary = await this.generateSummary(resource, context, annotationEntityTypes, config);
+    return {
+      summary,
+      relevantFields: {
+        resourceId: resource.id,
+        resourceName: resource.name,
+        entityTypes: annotationEntityTypes
+      },
+      context: {
+        before: context.before.substring(Math.max(0, context.before.length - 200)),
+        // Last 200 chars
+        selected: context.selected,
+        after: context.after.substring(0, 200)
+        // First 200 chars
       }
-    }
-    job.result = {
-      tagsFound: allTags.length,
-      tagsCreated: created,
-      byCategory
     };
-    job.progress = {
-      stage: "creating",
-      percentage: 100,
-      processedCategories: job.categories.length,
-      totalCategories: job.categories.length,
-      message: `Complete! Created ${created} tags`
-    };
-    await this.updateJobProgress(job);
-    console.log(`[TagDetectionWorker] \u2705 Created ${created}/${allTags.length} tags across ${job.categories.length} categories`);
   }
-  async createTagAnnotation(resourceId2, userId_, schemaId, tag) {
-    const backendUrl = this.config.services.backend?.publicURL;
-    if (!backendUrl) {
-      throw new Error("Backend publicURL not configured");
+  /**
+   * Get resource content as string
+   */
+  static async getResourceContent(resource, repStore) {
+    const primaryRep = getPrimaryRepresentation3(resource);
+    if (!primaryRep?.checksum || !primaryRep?.mediaType) {
+      throw new Error("Resource content not found");
     }
-    const resourceUri2 = resourceIdToURI5(resourceId2, backendUrl);
-    const annotationId2 = generateAnnotationId4(backendUrl);
-    const annotation = {
-      "@context": "http://www.w3.org/ns/anno.jsonld",
-      type: "Annotation",
-      id: annotationId2,
-      motivation: "tagging",
-      target: {
-        type: "SpecificResource",
-        source: resourceUri2,
-        selector: [
-          {
-            type: "TextPositionSelector",
-            start: tag.start,
-            end: tag.end
-          },
-          {
-            type: "TextQuoteSelector",
-            exact: tag.exact,
-            prefix: tag.prefix || "",
-            suffix: tag.suffix || ""
-          }
-        ]
-      },
-      body: [
-        {
-          type: "TextualBody",
-          value: tag.category,
-          purpose: "tagging",
-          format: "text/plain",
-          language: "en"
-        },
-        {
-          type: "TextualBody",
-          value: schemaId,
-          purpose: "classifying",
-          format: "text/plain"
-        }
-      ]
+    const content = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
+    return decodeRepresentation3(content, primaryRep.mediaType);
+  }
+  /**
+   * Extract annotation context from resource content
+   */
+  static extractAnnotationContext(annotation, contentStr, contextBefore, contextAfter) {
+    const targetSelector = getTargetSelector2(annotation.target);
+    const posSelector = targetSelector ? getTextPositionSelector(targetSelector) : null;
+    if (!posSelector) {
+      throw new Error("TextPositionSelector required for context");
+    }
+    const selStart = posSelector.start;
+    const selEnd = posSelector.end;
+    const start = Math.max(0, selStart - contextBefore);
+    const end = Math.min(contentStr.length, selEnd + contextAfter);
+    return {
+      before: contentStr.substring(start, selStart),
+      selected: contentStr.substring(selStart, selEnd),
+      after: contentStr.substring(selEnd, end)
     };
-    await this.eventStore.appendEvent({
-      type: "annotation.added",
-      resourceId: resourceId2,
-      userId: userId4(userId_),
-      version: 1,
-      payload: {
-        annotation
-      }
-    });
-    console.log(`[TagDetectionWorker] Created tag annotation ${annotationId2} for "${tag.category}": "${tag.exact.substring(0, 50)}..."`);
+  }
+  /**
+   * Generate LLM summary of annotation in context
+   * Creates inference client per-request (HTTP handler context)
+   */
+  static async generateSummary(resource, context, entityTypes, config) {
+    const summaryPrompt = `Summarize this text in context:
+
+Context before: "${context.before.substring(Math.max(0, context.before.length - 200))}"
+Selected exact: "${context.selected}"
+Context after: "${context.after.substring(0, 200)}"
+
+Resource: ${resource.name}
+Entity types: ${entityTypes.join(", ")}`;
+    const client = await getInferenceClient2(config);
+    return await client.generateText(summaryPrompt, 500, 0.5);
   }
 };
 
-// src/jobs/workers/reference-detection-worker.ts
-import { JobWorker as JobWorker5 } from "@semiont/jobs";
-import { generateAnnotationId as generateAnnotationId5 } from "@semiont/event-sourcing";
+// src/graph-context.ts
+import { getGraphDatabase as getGraphDatabase2 } from "@semiont/graph";
 import { resourceIdToURI as resourceIdToURI6 } from "@semiont/core";
-import {
-  getPrimaryRepresentation as getPrimaryRepresentation4,
-  decodeRepresentation as decodeRepresentation4,
-  validateAndCorrectOffsets
-} from "@semiont/api-client";
-import { extractEntities } from "@semiont/inference";
-import { FilesystemRepresentationStore as FilesystemRepresentationStore4 } from "@semiont/content";
-var ReferenceDetectionWorker = class extends JobWorker5 {
-  constructor(jobQueue, config, eventStore) {
-    super(jobQueue);
-    this.config = config;
-    this.eventStore = eventStore;
+var GraphContext = class {
+  /**
+   * Get all resources referencing this resource (backlinks)
+   * Requires graph traversal - must use graph database
+   */
+  static async getBacklinks(resourceId2, config) {
+    const graphDb = await getGraphDatabase2(config);
+    const resourceUri3 = resourceIdToURI6(resourceId2, config.services.backend.publicURL);
+    return await graphDb.getResourceReferencedBy(resourceUri3);
   }
-  getWorkerName() {
-    return "ReferenceDetectionWorker";
+  /**
+   * Find shortest path between two resources
+   * Requires graph traversal - must use graph database
+   */
+  static async findPath(fromResourceId, toResourceId, config, maxDepth) {
+    const graphDb = await getGraphDatabase2(config);
+    return await graphDb.findPath(fromResourceId, toResourceId, maxDepth);
   }
-  canProcessJob(job) {
-    return job.type === "detection";
+  /**
+   * Get resource connections (graph edges)
+   * Requires graph traversal - must use graph database
+   */
+  static async getResourceConnections(resourceId2, config) {
+    const graphDb = await getGraphDatabase2(config);
+    return await graphDb.getResourceConnections(resourceId2);
+  }
+  /**
+   * Search resources by name (cross-resource query)
+   * Requires full-text search - must use graph database
+   */
+  static async searchResources(query, config, limit) {
+    const graphDb = await getGraphDatabase2(config);
+    return await graphDb.searchResources(query, limit);
+  }
+};
+
+// src/annotation-detection.ts
+import { FilesystemRepresentationStore as FilesystemRepresentationStore6 } from "@semiont/content";
+import { getPrimaryRepresentation as getPrimaryRepresentation4, decodeRepresentation as decodeRepresentation4 } from "@semiont/api-client";
+
+// src/detection/motivation-prompts.ts
+var MotivationPrompts = class {
+  /**
+   * Build a prompt for detecting comment-worthy passages
+   *
+   * @param content - The text content to analyze (will be truncated to 8000 chars)
+   * @param instructions - Optional user-provided instructions
+   * @param tone - Optional tone guidance (e.g., "academic", "conversational")
+   * @param density - Optional target number of comments per 2000 words
+   * @returns Formatted prompt string
+   */
+  static buildCommentPrompt(content, instructions, tone, density) {
+    let prompt;
+    if (instructions) {
+      const toneGuidance = tone ? ` Use a ${tone} tone.` : "";
+      const densityGuidance = density ? `
+
+Aim for approximately ${density} comments per 2000 words of text.` : "";
+      prompt = `Add comments to passages in this text following these instructions:
+
+${instructions}${toneGuidance}${densityGuidance}
+
+Text to analyze:
+---
+${content.substring(0, 8e3)}
+---
+
+Return a JSON array of comments. Each comment must have:
+- "exact": the exact text passage being commented on (quoted verbatim from source)
+- "start": character offset where the passage starts
+- "end": character offset where the passage ends
+- "prefix": up to 32 characters of text immediately before the passage
+- "suffix": up to 32 characters of text immediately after the passage
+- "comment": your comment following the instructions above
+
+Return ONLY a valid JSON array, no additional text or explanation.
+
+Example:
+[
+  {"exact": "the quarterly review meeting", "start": 142, "end": 169, "prefix": "We need to schedule ", "suffix": " for next month.", "comment": "Who will lead this? Should we invite the external auditors?"}
+]`;
+    } else {
+      const toneGuidance = tone ? `
+
+Tone: Use a ${tone} style in your comments.` : "";
+      const densityGuidance = density ? `
+- Aim for approximately ${density} comments per 2000 words` : `
+- Aim for 3-8 comments per 2000 words (not too sparse or dense)`;
+      prompt = `Identify passages in this text that would benefit from explanatory comments.
+For each passage, provide contextual information, clarification, or background.${toneGuidance}
+
+Guidelines:
+- Select passages that reference technical terms, historical figures, complex concepts, or unclear references
+- Provide comments that ADD VALUE beyond restating the text
+- Focus on explanation, background, or connections to other ideas
+- Avoid obvious or trivial comments
+- Keep comments concise (1-3 sentences typically)${densityGuidance}
+
+Text to analyze:
+---
+${content.substring(0, 8e3)}
+---
+
+Return a JSON array of comments. Each comment should have:
+- "exact": the exact text passage being commented on (quoted verbatim from source)
+- "start": character offset where the passage starts
+- "end": character offset where the passage ends
+- "prefix": up to 32 characters of text immediately before the passage
+- "suffix": up to 32 characters of text immediately after the passage
+- "comment": your explanatory comment (1-3 sentences, provide context/background/clarification)
+
+Return ONLY a valid JSON array, no additional text or explanation.
+
+Example format:
+[
+  {"exact": "Ouranos", "start": 52, "end": 59, "prefix": "In the beginning, ", "suffix": " ruled the universe", "comment": "Ouranos (also spelled Uranus) is the primordial Greek deity personifying the sky. In Hesiod's Theogony, he is the son and husband of Gaia (Earth) and father of the Titans."}
+]`;
+    }
+    return prompt;
+  }
+  /**
+   * Build a prompt for detecting highlight-worthy passages
+   *
+   * @param content - The text content to analyze (will be truncated to 8000 chars)
+   * @param instructions - Optional user-provided instructions
+   * @param density - Optional target number of highlights per 2000 words
+   * @returns Formatted prompt string
+   */
+  static buildHighlightPrompt(content, instructions, density) {
+    let prompt;
+    if (instructions) {
+      const densityGuidance = density ? `
+
+Aim for approximately ${density} highlights per 2000 words of text.` : "";
+      prompt = `Identify passages in this text to highlight following these instructions:
+
+${instructions}${densityGuidance}
+
+Text to analyze:
+---
+${content.substring(0, 8e3)}
+---
+
+Return a JSON array of highlights. Each highlight must have:
+- "exact": the exact text passage to highlight (quoted verbatim from source)
+- "start": character offset where the passage starts
+- "end": character offset where the passage ends
+- "prefix": up to 32 characters of text immediately before the passage
+- "suffix": up to 32 characters of text immediately after the passage
+
+Return ONLY a valid JSON array, no additional text or explanation.
+
+Example:
+[
+  {"exact": "revenue grew 45% year-over-year", "start": 142, "end": 174, "prefix": "In Q3 2024, ", "suffix": ", exceeding all forecasts."}
+]`;
+    } else {
+      const densityGuidance = density ? `
+- Aim for approximately ${density} highlights per 2000 words` : `
+- Aim for 3-8 highlights per 2000 words (be selective)`;
+      prompt = `Identify passages in this text that merit highlighting for their importance or salience.
+Focus on content that readers should notice and remember.
+
+Guidelines:
+- Highlight key claims, findings, or conclusions
+- Highlight important definitions, terminology, or concepts
+- Highlight notable quotes or particularly striking statements
+- Highlight critical decisions, action items, or turning points
+- Select passages that are SIGNIFICANT, not just interesting
+- Avoid trivial or obvious content${densityGuidance}
+
+Text to analyze:
+---
+${content.substring(0, 8e3)}
+---
+
+Return a JSON array of highlights. Each highlight should have:
+- "exact": the exact text passage to highlight (quoted verbatim from source)
+- "start": character offset where the passage starts
+- "end": character offset where the passage ends
+- "prefix": up to 32 characters of text immediately before the passage
+- "suffix": up to 32 characters of text immediately after the passage
+
+Return ONLY a valid JSON array, no additional text or explanation.
+
+Example format:
+[
+  {"exact": "we will discontinue support for legacy systems by March 2025", "start": 52, "end": 113, "prefix": "After careful consideration, ", "suffix": ". This decision affects"}
+]`;
+    }
+    return prompt;
   }
-  async executeJob(job) {
-    if (job.type !== "detection") {
-      throw new Error(`Invalid job type: ${job.type}`);
+  /**
+   * Build a prompt for detecting assessment-worthy passages
+   *
+   * @param content - The text content to analyze (will be truncated to 8000 chars)
+   * @param instructions - Optional user-provided instructions
+   * @param tone - Optional tone guidance (e.g., "critical", "supportive")
+   * @param density - Optional target number of assessments per 2000 words
+   * @returns Formatted prompt string
+   */
+  static buildAssessmentPrompt(content, instructions, tone, density) {
+    let prompt;
+    if (instructions) {
+      const toneGuidance = tone ? ` Use a ${tone} tone.` : "";
+      const densityGuidance = density ? `
+
+Aim for approximately ${density} assessments per 2000 words of text.` : "";
+      prompt = `Assess passages in this text following these instructions:
+
+${instructions}${toneGuidance}${densityGuidance}
+
+Text to analyze:
+---
+${content.substring(0, 8e3)}
+---
+
+Return a JSON array of assessments. Each assessment must have:
+- "exact": the exact text passage being assessed (quoted verbatim from source)
+- "start": character offset where the passage starts
+- "end": character offset where the passage ends
+- "prefix": up to 32 characters of text immediately before the passage
+- "suffix": up to 32 characters of text immediately after the passage
+- "assessment": your assessment following the instructions above
+
+Return ONLY a valid JSON array, no additional text or explanation.
+
+Example:
+[
+  {"exact": "the quarterly revenue target", "start": 142, "end": 169, "prefix": "We established ", "suffix": " for Q4 2024.", "assessment": "This target seems ambitious given market conditions. Consider revising based on recent trends."}
+]`;
+    } else {
+      const toneGuidance = tone ? `
+
+Tone: Use a ${tone} style in your assessments.` : "";
+      const densityGuidance = density ? `
+- Aim for approximately ${density} assessments per 2000 words` : `
+- Aim for 2-6 assessments per 2000 words (focus on key passages)`;
+      prompt = `Identify passages in this text that merit critical assessment or evaluation.
+For each passage, provide analysis of its validity, strength, or implications.${toneGuidance}
+
+Guidelines:
+- Select passages containing claims, arguments, conclusions, or assertions
+- Assess evidence quality, logical soundness, or practical implications
+- Provide assessments that ADD INSIGHT beyond restating the text
+- Focus on passages where evaluation would help readers form judgments
+- Keep assessments concise yet substantive (1-3 sentences typically)${densityGuidance}
+
+Text to analyze:
+---
+${content.substring(0, 8e3)}
+---
+
+Return a JSON array of assessments. Each assessment should have:
+- "exact": the exact text passage being assessed (quoted verbatim from source)
+- "start": character offset where the passage starts
+- "end": character offset where the passage ends
+- "prefix": up to 32 characters of text immediately before the passage
+- "suffix": up to 32 characters of text immediately after the passage
+- "assessment": your analytical assessment (1-3 sentences, evaluate validity/strength/implications)
+
+Return ONLY a valid JSON array, no additional text or explanation.
+
+Example format:
+[
+  {"exact": "AI will replace most jobs by 2030", "start": 52, "end": 89, "prefix": "Many experts predict that ", "suffix": ", fundamentally reshaping", "assessment": "This claim lacks nuance and supporting evidence. Employment patterns historically show job transformation rather than wholesale replacement. The timeline appears speculative without specific sector analysis."}
+]`;
     }
-    await this.processDetectionJob(job);
+    return prompt;
   }
   /**
-   * Detect entity references in resource using AI
-   * Self-contained implementation for reference detection
+   * Build a prompt for detecting structural tags
    *
-   * Public for testing charset handling - see entity-detection-charset.test.ts
+   * @param content - The full text content to analyze (NOT truncated for structural analysis)
+   * @param category - The specific category to detect
+   * @param schemaName - Human-readable schema name
+   * @param schemaDescription - Schema description
+   * @param schemaDomain - Schema domain
+   * @param categoryDescription - Category description
+   * @param categoryExamples - Example questions/guidance for this category
+   * @returns Formatted prompt string
    */
-  async detectReferences(resource, entityTypes, includeDescriptiveReferences = false) {
-    console.log(`Detecting entities of types: ${entityTypes.join(", ")}${includeDescriptiveReferences ? " (including descriptive references)" : ""}`);
-    const detectedAnnotations = [];
-    const primaryRep = getPrimaryRepresentation4(resource);
-    if (!primaryRep) return detectedAnnotations;
-    const mediaType = primaryRep.mediaType;
-    const baseMediaType = mediaType?.split(";")[0]?.trim() || "";
-    if (baseMediaType === "text/plain" || baseMediaType === "text/markdown") {
-      if (!primaryRep.checksum || !primaryRep.mediaType) return detectedAnnotations;
-      const basePath = this.config.services.filesystem.path;
-      const projectRoot = this.config._metadata?.projectRoot;
-      const repStore = new FilesystemRepresentationStore4({ basePath }, projectRoot);
-      const contentBuffer = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
-      const content = decodeRepresentation4(contentBuffer, primaryRep.mediaType);
-      const extractedEntities = await extractEntities(content, entityTypes, this.config, includeDescriptiveReferences);
-      for (const entity of extractedEntities) {
+  static buildTagPrompt(content, category, schemaName, schemaDescription, schemaDomain, categoryDescription, categoryExamples) {
+    const prompt = `You are analyzing a text using the ${schemaName} framework.
+
+Schema: ${schemaDescription}
+Domain: ${schemaDomain}
+
+Your task: Identify passages that serve the structural role of "${category}".
+
+Category: ${category}
+Description: ${categoryDescription}
+Key questions:
+${categoryExamples.map((ex) => `- ${ex}`).join("\n")}
+
+Guidelines:
+- Focus on STRUCTURAL FUNCTION, not semantic content
+- A passage serves the "${category}" role if it performs this function in the document's structure
+- Look for passages that explicitly fulfill this role
+- Passages can be sentences, paragraphs, or sections
+- Aim for precision - only tag passages that clearly serve this structural role
+- Typical documents have 1-5 instances of each category (some may have 0)
+
+Text to analyze:
+---
+${content}
+---
+
+Return a JSON array of tags. Each tag should have:
+- "exact": the exact text passage (quoted verbatim from source)
+- "start": character offset where the passage starts
+- "end": character offset where the passage ends
+- "prefix": up to 32 characters of text immediately before the passage
+- "suffix": up to 32 characters of text immediately after the passage
+
+Return ONLY a valid JSON array, no additional text or explanation.
+
+Example format:
+[
+  {"exact": "What duty did the defendant owe?", "start": 142, "end": 175, "prefix": "The central question is: ", "suffix": " This question must be"},
+  {"exact": "In tort law, a duty of care is established when...", "start": 412, "end": 520, "prefix": "Legal framework:\\n", "suffix": "\\n\\nApplying this standard"}
+]`;
+    return prompt;
+  }
+};
+
+// src/detection/motivation-parsers.ts
+import { validateAndCorrectOffsets as validateAndCorrectOffsets2 } from "@semiont/api-client";
+var MotivationParsers = class {
+  /**
+   * Parse and validate AI response for comment detection
+   *
+   * @param response - Raw AI response string (may include markdown code fences)
+   * @param content - Original content to validate offsets against
+   * @returns Array of validated comment matches
+   */
+  static parseComments(response, content) {
+    try {
+      let cleaned = response.trim();
+      if (cleaned.startsWith("```")) {
+        cleaned = cleaned.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+      }
+      const parsed = JSON.parse(cleaned);
+      if (!Array.isArray(parsed)) {
+        console.warn("[MotivationParsers] Comment response is not an array");
+        return [];
+      }
+      const valid = parsed.filter(
+        (c) => c && typeof c.exact === "string" && typeof c.start === "number" && typeof c.end === "number" && typeof c.comment === "string" && c.comment.trim().length > 0
+      );
+      console.log(`[MotivationParsers] Parsed ${valid.length} valid comments from ${parsed.length} total`);
+      const validatedComments = [];
+      for (const comment of valid) {
         try {
-          const validated = validateAndCorrectOffsets(
-            content,
-            entity.startOffset,
-            entity.endOffset,
-            entity.exact
-          );
-          const annotation = {
-            annotation: {
-              selector: {
-                start: validated.start,
-                end: validated.end,
-                exact: validated.exact,
-                prefix: validated.prefix,
-                suffix: validated.suffix
-              },
-              entityTypes: [entity.entityType]
-            }
-          };
-          detectedAnnotations.push(annotation);
+          const validated = validateAndCorrectOffsets2(content, comment.start, comment.end, comment.exact);
+          validatedComments.push({
+            ...comment,
+            start: validated.start,
+            end: validated.end,
+            prefix: validated.prefix,
+            suffix: validated.suffix
+          });
         } catch (error) {
-          console.warn(`[ReferenceDetectionWorker] Skipping invalid entity "${entity.exact}":`, error);
+          console.warn(`[MotivationParsers] Skipping invalid comment "${comment.exact}":`, error);
         }
       }
+      return validatedComments;
+    } catch (error) {
+      console.error("[MotivationParsers] Failed to parse AI comment response:", error);
+      return [];
     }
-    return detectedAnnotations;
   }
-  async processDetectionJob(job) {
-    console.log(`[ReferenceDetectionWorker] Processing detection for resource ${job.resourceId} (job: ${job.id})`);
-    console.log(`[ReferenceDetectionWorker] \u{1F50D} Entity types: ${job.entityTypes.join(", ")}`);
-    const resource = await ResourceContext.getResourceMetadata(job.resourceId, this.config);
-    if (!resource) {
-      throw new Error(`Resource ${job.resourceId} not found`);
-    }
-    let totalFound = 0;
-    let totalEmitted = 0;
-    let totalErrors = 0;
-    job.progress = {
-      totalEntityTypes: job.entityTypes.length,
-      processedEntityTypes: 0,
-      entitiesFound: 0,
-      entitiesEmitted: 0
-    };
-    await this.updateJobProgress(job);
-    for (let i = 0; i < job.entityTypes.length; i++) {
-      const entityType = job.entityTypes[i];
-      if (!entityType) continue;
-      console.log(`[ReferenceDetectionWorker] \u{1F916} [${i + 1}/${job.entityTypes.length}] Detecting ${entityType}...`);
-      const detectedAnnotations = await this.detectReferences(resource, [entityType], job.includeDescriptiveReferences);
-      totalFound += detectedAnnotations.length;
-      console.log(`[ReferenceDetectionWorker] \u2705 Found ${detectedAnnotations.length} ${entityType} entities`);
-      for (let idx = 0; idx < detectedAnnotations.length; idx++) {
-        const detected = detectedAnnotations[idx];
-        if (!detected) {
-          console.warn(`[ReferenceDetectionWorker] Skipping undefined entity at index ${idx}`);
-          continue;
-        }
-        let referenceId;
-        try {
-          const backendUrl = this.config.services.backend?.publicURL;
-          if (!backendUrl) {
-            throw new Error("Backend publicURL not configured");
-          }
-          referenceId = generateAnnotationId5(backendUrl);
-        } catch (error) {
-          console.error(`[ReferenceDetectionWorker] Failed to generate annotation ID:`, error);
-          job.status = "failed";
-          job.error = "Configuration error: Backend publicURL not set";
-          await this.updateJobProgress(job);
-          return;
+  /**
+   * Parse and validate AI response for highlight detection
+   *
+   * @param response - Raw AI response string (may include markdown code fences)
+   * @param content - Original content to validate offsets against
+   * @returns Array of validated highlight matches
+   */
+  static parseHighlights(response, content) {
+    try {
+      let cleaned = response.trim();
+      if (cleaned.startsWith("```json") || cleaned.startsWith("```")) {
+        cleaned = cleaned.slice(cleaned.indexOf("\n") + 1);
+        const endIndex = cleaned.lastIndexOf("```");
+        if (endIndex !== -1) {
+          cleaned = cleaned.slice(0, endIndex);
         }
+      }
+      const parsed = JSON.parse(cleaned);
+      if (!Array.isArray(parsed)) {
+        console.warn("[MotivationParsers] Highlight response was not an array");
+        return [];
+      }
+      const highlights = parsed.filter(
+        (h) => h && typeof h.exact === "string" && typeof h.start === "number" && typeof h.end === "number"
+      );
+      const validatedHighlights = [];
+      for (const highlight of highlights) {
         try {
-          await this.eventStore.appendEvent({
-            type: "annotation.added",
-            resourceId: job.resourceId,
-            userId: job.userId,
-            version: 1,
-            payload: {
-              annotation: {
-                "@context": "http://www.w3.org/ns/anno.jsonld",
-                "type": "Annotation",
-                id: referenceId,
-                motivation: "linking",
-                target: {
-                  source: resourceIdToURI6(job.resourceId, this.config.services.backend.publicURL),
-                  // Convert to full URI
-                  selector: [
-                    {
-                      type: "TextPositionSelector",
-                      start: detected.annotation.selector.start,
-                      end: detected.annotation.selector.end
-                    },
-                    {
-                      type: "TextQuoteSelector",
-                      exact: detected.annotation.selector.exact,
-                      ...detected.annotation.selector.prefix && { prefix: detected.annotation.selector.prefix },
-                      ...detected.annotation.selector.suffix && { suffix: detected.annotation.selector.suffix }
-                    }
-                  ]
-                },
-                body: (detected.annotation.entityTypes || []).map((et) => ({
-                  type: "TextualBody",
-                  value: et,
-                  purpose: "tagging"
-                })),
-                modified: (/* @__PURE__ */ new Date()).toISOString()
-              }
-            }
+          const validated = validateAndCorrectOffsets2(content, highlight.start, highlight.end, highlight.exact);
+          validatedHighlights.push({
+            ...highlight,
+            start: validated.start,
+            end: validated.end,
+            prefix: validated.prefix,
+            suffix: validated.suffix
           });
-          totalEmitted++;
-          if ((idx + 1) % 10 === 0 || idx === detectedAnnotations.length - 1) {
-            console.log(`[ReferenceDetectionWorker] \u{1F4E4} Emitted ${idx + 1}/${detectedAnnotations.length} events for ${entityType}`);
-          }
         } catch (error) {
-          totalErrors++;
-          console.error(`[ReferenceDetectionWorker] \u274C Failed to emit event for ${referenceId}:`, error);
+          console.warn(`[MotivationParsers] Skipping invalid highlight "${highlight.exact}":`, error);
         }
       }
-      console.log(`[ReferenceDetectionWorker] \u2705 Completed ${entityType}: ${detectedAnnotations.length} found, ${detectedAnnotations.length - (totalErrors - (totalFound - totalEmitted))} emitted`);
-      job.progress = {
-        totalEntityTypes: job.entityTypes.length,
-        processedEntityTypes: i + 1,
-        currentEntityType: entityType,
-        entitiesFound: totalFound,
-        entitiesEmitted: totalEmitted
-      };
-      await this.updateJobProgress(job);
-    }
-    job.result = {
-      totalFound,
-      totalEmitted,
-      errors: totalErrors
-    };
-    console.log(`[ReferenceDetectionWorker] \u2705 Detection complete: ${totalFound} entities found, ${totalEmitted} events emitted, ${totalErrors} errors`);
-  }
-  async handleJobFailure(job, error) {
-    await super.handleJobFailure(job, error);
-    if (job.status === "failed" && job.type === "detection") {
-      const detJob = job;
-      await this.eventStore.appendEvent({
-        type: "job.failed",
-        resourceId: detJob.resourceId,
-        userId: detJob.userId,
-        version: 1,
-        payload: {
-          jobId: detJob.id,
-          jobType: detJob.type,
-          error: "Entity detection failed. Please try again later."
-        }
-      });
+      return validatedHighlights;
+    } catch (error) {
+      console.error("[MotivationParsers] Failed to parse AI highlight response:", error);
+      console.error("Raw response:", response);
+      return [];
     }
   }
   /**
-   * Update job progress and emit events to Event Store
-   * Overrides base class to also emit job progress events
+   * Parse and validate AI response for assessment detection
+   *
+   * @param response - Raw AI response string (may include markdown code fences)
+   * @param content - Original content to validate offsets against
+   * @returns Array of validated assessment matches
    */
-  async updateJobProgress(job) {
-    await super.updateJobProgress(job);
-    if (job.type !== "detection") {
-      return;
-    }
-    const detJob = job;
-    const baseEvent = {
-      resourceId: detJob.resourceId,
-      userId: detJob.userId,
-      version: 1
-    };
-    if (!detJob.progress) {
-      return;
-    }
-    const isFirstUpdate = detJob.progress.processedEntityTypes === 0;
-    const isFinalUpdate = detJob.progress.processedEntityTypes === detJob.progress.totalEntityTypes && detJob.progress.totalEntityTypes > 0;
-    if (isFirstUpdate) {
-      await this.eventStore.appendEvent({
-        type: "job.started",
-        ...baseEvent,
-        payload: {
-          jobId: detJob.id,
-          jobType: detJob.type,
-          totalSteps: detJob.entityTypes.length
-        }
-      });
-    } else if (isFinalUpdate) {
-      await this.eventStore.appendEvent({
-        type: "job.completed",
-        ...baseEvent,
-        payload: {
-          jobId: detJob.id,
-          jobType: detJob.type,
-          foundCount: detJob.progress.entitiesFound
+  static parseAssessments(response, content) {
+    try {
+      let cleaned = response.trim();
+      if (cleaned.startsWith("```json") || cleaned.startsWith("```")) {
+        cleaned = cleaned.slice(cleaned.indexOf("\n") + 1);
+        const endIndex = cleaned.lastIndexOf("```");
+        if (endIndex !== -1) {
+          cleaned = cleaned.slice(0, endIndex);
         }
-      });
-    } else {
-      const percentage = Math.round(detJob.progress.processedEntityTypes / detJob.progress.totalEntityTypes * 100);
-      await this.eventStore.appendEvent({
-        type: "job.progress",
-        ...baseEvent,
-        payload: {
-          jobId: detJob.id,
-          jobType: detJob.type,
-          percentage,
-          currentStep: detJob.progress.currentEntityType,
-          processedSteps: detJob.progress.processedEntityTypes,
-          totalSteps: detJob.progress.totalEntityTypes,
-          foundCount: detJob.progress.entitiesFound
+      }
+      const parsed = JSON.parse(cleaned);
+      if (!Array.isArray(parsed)) {
+        console.warn("[MotivationParsers] Assessment response was not an array");
+        return [];
+      }
+      const assessments = parsed.filter(
+        (a) => a && typeof a.exact === "string" && typeof a.start === "number" && typeof a.end === "number" && typeof a.assessment === "string"
+      );
+      const validatedAssessments = [];
+      for (const assessment of assessments) {
+        try {
+          const validated = validateAndCorrectOffsets2(content, assessment.start, assessment.end, assessment.exact);
+          validatedAssessments.push({
+            ...assessment,
+            start: validated.start,
+            end: validated.end,
+            prefix: validated.prefix,
+            suffix: validated.suffix
+          });
+        } catch (error) {
+          console.warn(`[MotivationParsers] Skipping invalid assessment "${assessment.exact}":`, error);
         }
-      });
+      }
+      return validatedAssessments;
+    } catch (error) {
+      console.error("[MotivationParsers] Failed to parse AI assessment response:", error);
+      console.error("Raw response:", response);
+      return [];
     }
   }
-};
-
-// src/jobs/workers/generation-worker.ts
-import { JobWorker as JobWorker6 } from "@semiont/jobs";
-import { FilesystemRepresentationStore as FilesystemRepresentationStore5 } from "@semiont/content";
-import { generateResourceFromTopic } from "@semiont/inference";
-import {
-  getTargetSelector as getTargetSelector2,
-  getExactText,
-  resourceUri,
-  annotationUri
-} from "@semiont/api-client";
-import { getEntityTypes as getEntityTypes2 } from "@semiont/ontology";
-import {
-  CREATION_METHODS,
-  generateUuid,
-  resourceId,
-  annotationId
-} from "@semiont/core";
-var GenerationWorker = class extends JobWorker6 {
-  constructor(jobQueue, config, eventStore) {
-    super(jobQueue);
-    this.config = config;
-    this.eventStore = eventStore;
+  /**
+   * Parse and validate AI response for tag detection
+   * Note: Does NOT validate offsets - caller must do that with content
+   *
+   * @param response - Raw AI response string (may include markdown code fences)
+   * @returns Array of tag matches (offsets not yet validated)
+   */
+  static parseTags(response) {
+    try {
+      let cleaned = response.trim();
+      if (cleaned.startsWith("```")) {
+        cleaned = cleaned.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+      }
+      const parsed = JSON.parse(cleaned);
+      if (!Array.isArray(parsed)) {
+        console.warn("[MotivationParsers] Tag response is not an array");
+        return [];
+      }
+      const valid = parsed.filter(
+        (t) => t && typeof t.exact === "string" && typeof t.start === "number" && typeof t.end === "number" && t.exact.trim().length > 0
+      );
+      console.log(`[MotivationParsers] Parsed ${valid.length} valid tags from ${parsed.length} total`);
+      return valid;
+    } catch (error) {
+      console.error("[MotivationParsers] Failed to parse AI tag response:", error);
+      return [];
+    }
   }
-  getWorkerName() {
-    return "GenerationWorker";
+  /**
+   * Validate tag offsets against content and add category
+   * Helper for tag detection after initial parsing
+   *
+   * @param tags - Parsed tags without validated offsets
+   * @param content - Original content to validate against
+   * @param category - Category to assign to validated tags
+   * @returns Array of validated tag matches
+   */
+  static validateTagOffsets(tags, content, category) {
+    const validatedTags = [];
+    for (const tag of tags) {
+      try {
+        const validated = validateAndCorrectOffsets2(content, tag.start, tag.end, tag.exact);
+        validatedTags.push({
+          ...tag,
+          category,
+          start: validated.start,
+          end: validated.end,
+          prefix: validated.prefix,
+          suffix: validated.suffix
+        });
+      } catch (error) {
+        console.warn(`[MotivationParsers] Skipping invalid tag for category "${category}":`, error);
+      }
+    }
+    return validatedTags;
   }
-  canProcessJob(job) {
-    return job.type === "generation";
+};
+
+// src/annotation-detection.ts
+import { getTagSchema as getTagSchema2, getSchemaCategory } from "@semiont/ontology";
+var AnnotationDetection = class {
+  /**
+   * Detect comments in a resource
+   *
+   * @param resourceId - The resource to analyze
+   * @param config - Environment configuration
+   * @param client - Inference client for AI operations
+   * @param instructions - Optional user instructions for comment generation
+   * @param tone - Optional tone guidance (e.g., "academic", "conversational")
+   * @param density - Optional target number of comments per 2000 words
+   * @returns Array of validated comment matches
+   */
+  static async detectComments(resourceId2, config, client, instructions, tone, density) {
+    const resource = await ResourceContext.getResourceMetadata(resourceId2, config);
+    if (!resource) {
+      throw new Error(`Resource ${resourceId2} not found`);
+    }
+    const content = await this.loadResourceContent(resourceId2, config);
+    if (!content) {
+      throw new Error(`Could not load content for resource ${resourceId2}`);
+    }
+    const prompt = MotivationPrompts.buildCommentPrompt(content, instructions, tone, density);
+    const response = await client.generateText(
+      prompt,
+      3e3,
+      // maxTokens: Higher than highlights/assessments due to comment text
+      0.4
+      // temperature: Slightly higher to allow creative context
+    );
+    return MotivationParsers.parseComments(response, content);
   }
-  async executeJob(job) {
-    if (job.type !== "generation") {
-      throw new Error(`Invalid job type: ${job.type}`);
+  /**
+   * Detect highlights in a resource
+   *
+   * @param resourceId - The resource to analyze
+   * @param config - Environment configuration
+   * @param client - Inference client for AI operations
+   * @param instructions - Optional user instructions for highlight selection
+   * @param density - Optional target number of highlights per 2000 words
+   * @returns Array of validated highlight matches
+   */
+  static async detectHighlights(resourceId2, config, client, instructions, density) {
+    const resource = await ResourceContext.getResourceMetadata(resourceId2, config);
+    if (!resource) {
+      throw new Error(`Resource ${resourceId2} not found`);
     }
-    await this.processGenerationJob(job);
+    const content = await this.loadResourceContent(resourceId2, config);
+    if (!content) {
+      throw new Error(`Could not load content for resource ${resourceId2}`);
+    }
+    const prompt = MotivationPrompts.buildHighlightPrompt(content, instructions, density);
+    const response = await client.generateText(
+      prompt,
+      2e3,
+      // maxTokens: Lower than comments/assessments (no body text)
+      0.3
+      // temperature: Low for consistent importance judgments
+    );
+    return MotivationParsers.parseHighlights(response, content);
   }
-  async processGenerationJob(job) {
-    console.log(`[GenerationWorker] Processing generation for reference ${job.referenceId} (job: ${job.id})`);
-    const basePath = this.config.services.filesystem.path;
-    const projectRoot = this.config._metadata?.projectRoot;
-    const repStore = new FilesystemRepresentationStore5({ basePath }, projectRoot);
-    job.progress = {
-      stage: "fetching",
-      percentage: 20,
-      message: "Fetching source resource..."
-    };
-    console.log(`[GenerationWorker] \u{1F4E5} ${job.progress.message}`);
-    await this.updateJobProgress(job);
-    const { FilesystemViewStorage: FilesystemViewStorage3 } = await import("@semiont/event-sourcing");
-    const viewStorage = new FilesystemViewStorage3(basePath, projectRoot);
-    const view = await viewStorage.get(job.sourceResourceId);
-    if (!view) {
-      throw new Error(`Resource ${job.sourceResourceId} not found`);
+  /**
+   * Detect assessments in a resource
+   *
+   * @param resourceId - The resource to analyze
+   * @param config - Environment configuration
+   * @param client - Inference client for AI operations
+   * @param instructions - Optional user instructions for assessment generation
+   * @param tone - Optional tone guidance (e.g., "critical", "supportive")
+   * @param density - Optional target number of assessments per 2000 words
+   * @returns Array of validated assessment matches
+   */
+  static async detectAssessments(resourceId2, config, client, instructions, tone, density) {
+    const resource = await ResourceContext.getResourceMetadata(resourceId2, config);
+    if (!resource) {
+      throw new Error(`Resource ${resourceId2} not found`);
     }
-    const projection = view.annotations;
-    const expectedAnnotationUri = `${this.config.services.backend.publicURL}/annotations/${job.referenceId}`;
-    const annotation = projection.annotations.find(
-      (a) => a.id === expectedAnnotationUri && a.motivation === "linking"
+    const content = await this.loadResourceContent(resourceId2, config);
+    if (!content) {
+      throw new Error(`Could not load content for resource ${resourceId2}`);
+    }
+    const prompt = MotivationPrompts.buildAssessmentPrompt(content, instructions, tone, density);
+    const response = await client.generateText(
+      prompt,
+      3e3,
+      // maxTokens: Higher for assessment text
+      0.3
+      // temperature: Lower for analytical consistency
     );
-    if (!annotation) {
-      throw new Error(`Annotation ${job.referenceId} not found in resource ${job.sourceResourceId}`);
+    return MotivationParsers.parseAssessments(response, content);
+  }
+  /**
+   * Detect tags in a resource for a specific category
+   *
+   * @param resourceId - The resource to analyze
+   * @param config - Environment configuration
+   * @param client - Inference client for AI operations
+   * @param schemaId - The tag schema identifier (e.g., "irac", "imrad")
+   * @param category - The specific category to detect
+   * @returns Array of validated tag matches
+   */
+  static async detectTags(resourceId2, config, client, schemaId, category) {
+    const schema = getTagSchema2(schemaId);
+    if (!schema) {
+      throw new Error(`Invalid tag schema: ${schemaId}`);
     }
-    const sourceResource = await ResourceContext.getResourceMetadata(job.sourceResourceId, this.config);
-    if (!sourceResource) {
-      throw new Error(`Source resource ${job.sourceResourceId} not found`);
+    const categoryInfo = getSchemaCategory(schemaId, category);
+    if (!categoryInfo) {
+      throw new Error(`Invalid category "${category}" for schema ${schemaId}`);
     }
-    const targetSelector = getTargetSelector2(annotation.target);
-    const resourceName = job.title || (targetSelector ? getExactText(targetSelector) : "") || "New Resource";
-    console.log(`[GenerationWorker] Generating resource: "${resourceName}"`);
-    if (!job.context) {
-      throw new Error("Generation context is required but was not provided in job");
+    const resource = await ResourceContext.getResourceMetadata(resourceId2, config);
+    if (!resource) {
+      throw new Error(`Resource ${resourceId2} not found`);
     }
-    console.log(`[GenerationWorker] Using pre-fetched context: ${job.context.sourceContext?.before?.length || 0} chars before, ${job.context.sourceContext?.selected?.length || 0} chars selected, ${job.context.sourceContext?.after?.length || 0} chars after`);
-    job.progress = {
-      stage: "generating",
-      percentage: 40,
-      message: "Creating content with AI..."
-    };
-    console.log(`[GenerationWorker] \u{1F916} ${job.progress.message}`);
-    await this.updateJobProgress(job);
-    const prompt = job.prompt || `Create a comprehensive resource about "${resourceName}"`;
-    const annotationEntityTypes = getEntityTypes2({ body: annotation.body });
-    const generatedContent = await generateResourceFromTopic(
-      resourceName,
-      job.entityTypes || annotationEntityTypes,
-      this.config,
+    const content = await this.loadResourceContent(resourceId2, config);
+    if (!content) {
+      throw new Error(`Could not load content for resource ${resourceId2}`);
+    }
+    const prompt = MotivationPrompts.buildTagPrompt(
+      content,
+      category,
+      schema.name,
+      schema.description,
+      schema.domain,
+      categoryInfo.description,
+      categoryInfo.examples
+    );
+    const response = await client.generateText(
       prompt,
-      job.language,
-      job.context,
-      // NEW - context from job (passed from modal)
-      job.temperature,
-      // NEW - from job
-      job.maxTokens
-      // NEW - from job
+      4e3,
+      // maxTokens: Higher for full document analysis
+      0.2
+      // temperature: Lower for structural consistency
     );
-    console.log(`[GenerationWorker] \u2705 Generated ${generatedContent.content.length} bytes of content`);
-    job.progress = {
-      stage: "generating",
-      percentage: 70,
-      message: "Content ready, creating resource..."
-    };
-    await this.updateJobProgress(job);
-    const rId = resourceId(generateUuid());
-    job.progress = {
-      stage: "creating",
-      percentage: 85,
-      message: "Saving resource..."
-    };
-    console.log(`[GenerationWorker] \u{1F4BE} ${job.progress.message}`);
-    await this.updateJobProgress(job);
-    const storedRep = await repStore.store(Buffer.from(generatedContent.content), {
-      mediaType: "text/markdown",
-      rel: "original"
-    });
-    console.log(`[GenerationWorker] \u2705 Saved resource representation to filesystem: ${rId}`);
-    await this.eventStore.appendEvent({
-      type: "resource.created",
-      resourceId: rId,
-      userId: job.userId,
-      version: 1,
-      payload: {
-        name: resourceName,
-        format: "text/markdown",
-        contentChecksum: storedRep.checksum,
-        creationMethod: CREATION_METHODS.GENERATED,
-        entityTypes: job.entityTypes || annotationEntityTypes,
-        language: job.language,
-        isDraft: true,
-        generatedFrom: job.referenceId,
-        generationPrompt: void 0
-        // Could be added if we track the prompt
-      }
-    });
-    console.log(`[GenerationWorker] Emitted resource.created event for ${rId}`);
-    job.progress = {
-      stage: "linking",
-      percentage: 95,
-      message: "Linking reference..."
-    };
-    console.log(`[GenerationWorker] \u{1F517} ${job.progress.message}`);
-    await this.updateJobProgress(job);
-    const newResourceUri = resourceUri(`${this.config.services.backend.publicURL}/resources/${rId}`);
-    const operations = [{
-      op: "add",
-      item: {
-        type: "SpecificResource",
-        source: newResourceUri,
-        purpose: "linking"
-      }
-    }];
-    const annotationIdSegment = job.referenceId.split("/").pop();
-    await this.eventStore.appendEvent({
-      type: "annotation.body.updated",
-      resourceId: job.sourceResourceId,
-      userId: job.userId,
-      version: 1,
-      payload: {
-        annotationId: annotationId(annotationIdSegment),
-        operations
-      }
-    });
-    console.log(`[GenerationWorker] \u2705 Emitted annotation.body.updated event linking ${job.referenceId} \u2192 ${rId}`);
-    job.result = {
-      resourceId: rId,
-      resourceName
-    };
-    job.progress = {
-      stage: "linking",
-      percentage: 100,
-      message: "Complete!"
-    };
-    await this.updateJobProgress(job);
-    console.log(`[GenerationWorker] \u2705 Generation complete: created resource ${rId}`);
+    const parsedTags = MotivationParsers.parseTags(response);
+    return MotivationParsers.validateTagOffsets(parsedTags, content, category);
   }
   /**
-   * Update job progress and emit events to Event Store
-   * Overrides base class to also emit job progress events
+   * Load resource content from representation store
+   * Helper method used by all detection methods
+   *
+   * @param resourceId - The resource ID to load
+   * @param config - Environment configuration
+   * @returns Resource content as string, or null if not available
    */
-  async updateJobProgress(job) {
-    await super.updateJobProgress(job);
-    if (job.type !== "generation") {
-      return;
-    }
-    const genJob = job;
-    const baseEvent = {
-      resourceId: genJob.sourceResourceId,
-      userId: genJob.userId,
-      version: 1
-    };
-    if (genJob.progress?.stage === "fetching" && genJob.progress?.percentage === 20) {
-      await this.eventStore.appendEvent({
-        type: "job.started",
-        ...baseEvent,
-        payload: {
-          jobId: genJob.id,
-          jobType: genJob.type,
-          totalSteps: 5
-          // fetching, generating, creating, linking, complete
-        }
-      });
-    } else if (genJob.progress?.stage === "linking" && genJob.progress?.percentage === 100) {
-      await this.eventStore.appendEvent({
-        type: "job.completed",
-        ...baseEvent,
-        payload: {
-          jobId: genJob.id,
-          jobType: genJob.type,
-          resultResourceId: genJob.result?.resourceId,
-          annotationUri: annotationUri(`${this.config.services.backend.publicURL}/annotations/${genJob.referenceId}`)
-        }
-      });
-    } else if (genJob.progress) {
-      await this.eventStore.appendEvent({
-        type: "job.progress",
-        ...baseEvent,
-        payload: {
-          jobId: genJob.id,
-          jobType: genJob.type,
-          currentStep: genJob.progress.stage,
-          percentage: genJob.progress.percentage,
-          message: genJob.progress.message
-        }
-      });
+  static async loadResourceContent(resourceId2, config) {
+    const resource = await ResourceContext.getResourceMetadata(resourceId2, config);
+    if (!resource) return null;
+    const primaryRep = getPrimaryRepresentation4(resource);
+    if (!primaryRep) return null;
+    const baseMediaType = primaryRep.mediaType?.split(";")[0]?.trim() || "";
+    if (baseMediaType !== "text/plain" && baseMediaType !== "text/markdown") {
+      return null;
     }
+    if (!primaryRep.checksum || !primaryRep.mediaType) return null;
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const repStore = new FilesystemRepresentationStore6({ basePath }, projectRoot);
+    const contentBuffer = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
+    return decodeRepresentation4(contentBuffer, primaryRep.mediaType);
   }
 };
 
@@ -1985,11 +3290,19 @@ export {
   CommentDetectionWorker,
   GenerationWorker,
   GraphContext,
+  GraphDBConsumer,
   HighlightDetectionWorker,
+  MotivationParsers,
+  MotivationPrompts,
   PACKAGE_NAME,
   ReferenceDetectionWorker,
   ResourceContext,
   TagDetectionWorker,
-  VERSION
+  VERSION,
+  extractEntities,
+  generateReferenceSuggestions,
+  generateResourceFromTopic,
+  generateResourceSummary,
+  startMakeMeaning
 };
 //# sourceMappingURL=index.js.map