@semiont/make-meaning 0.2.30 → 0.2.31

package/dist/index.js

@@ -1,16 +1,2111 @@
+// 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";
+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}`);
+    }
+    if (job.status !== "running") {
+      throw new Error(`Job must be in running state to execute, got: ${job.status}`);
+    }
+    await this.processDetectionJob(job);
+  }
+  /**
+   * Detect entity references in resource using AI
+   * Self-contained implementation for reference detection
+   *
+   * Public for testing charset handling - see entity-detection-charset.test.ts
+   */
+  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);
+        }
+      }
+    }
+    return detectedAnnotations;
+  }
+  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 backendUrl = this.config.services.backend?.publicURL;
+          if (!backendUrl) {
+            throw new Error("Backend publicURL not configured");
+          }
+          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."
+        }
+      });
+    }
+  }
+  /**
+   * Update job progress and emit events to Event Store
+   * Overrides base class to also emit job progress events
+   */
+  async updateJobProgress(job) {
+    await super.updateJobProgress(job);
+    if (job.metadata.type !== "detection") {
+      return;
+    }
+    if (job.status !== "running") {
+      return;
+    }
+    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 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
+        }
+      });
+    }
+  }
+};
+
+// 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);
+      }
+    } else if (content.startsWith("```")) {
+      content = content.slice(3);
+      const endIndex = content.lastIndexOf("```");
+      if (endIndex !== -1) {
+        content = content.slice(0, endIndex);
+      }
+    }
+    content = content.trim();
+    return {
+      title: topic,
+      content
+    };
+  };
+  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;
+  }
+  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;
+  }
+  getWorkerName() {
+    return "GenerationWorker";
+  }
+  canProcessJob(job) {
+    return job.metadata.type === "generation";
+  }
+  async executeJob(job) {
+    if (job.metadata.type !== "generation") {
+      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}`);
+    }
+    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`);
+    }
+    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 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..."
+      }
+    };
+    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"
+    });
+    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
+      }
+    });
+    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
+      }
+    });
+    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}`);
+  }
+  /**
+   * Update job progress and emit events to Event Store
+   * Overrides base class to also emit job progress events
+   */
+  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
+        }
+      });
+    }
+  }
+};
+
+// 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;
+  }
+  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}`);
+    }
+    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);
+  }
+  /**
+   * Override updateJobProgress to emit events to Event Store
+   */
+  async updateJobProgress(job) {
+    await super.updateJobProgress(job);
+    if (job.metadata.type !== "highlight-detection") return;
+    if (job.status !== "running") {
+      return;
+    }
+    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 ${job.params.resourceId} not found`);
+    }
+    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 highlights = await AnnotationDetection.detectHighlights(
+      job.params.resourceId,
+      this.config,
+      this.inferenceClient,
+      job.params.instructions,
+      job.params.density
+    );
+    console.log(`[HighlightDetectionWorker] Found ${highlights.length} highlights to create`);
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 60,
+        message: `Creating ${highlights.length} annotations...`
+      }
+    };
+    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);
+      }
+    }
+    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`);
+  }
+  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/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;
+  }
+  isFirstProgress = true;
+  getWorkerName() {
+    return "AssessmentDetectionWorker";
+  }
+  canProcessJob(job) {
+    return job.metadata.type === "assessment-detection";
+  }
+  async executeJob(job) {
+    if (job.metadata.type !== "assessment-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.processAssessmentDetectionJob(job);
+  }
+  /**
+   * Override updateJobProgress to emit events to Event Store
+   */
+  async updateJobProgress(job) {
+    await super.updateJobProgress(job);
+    if (job.metadata.type !== "assessment-detection") return;
+    if (job.status !== "running") {
+      return;
+    }
+    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
+        }
+      });
+    }
+  }
+  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."
+        }
+      });
+    }
+  }
+  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 ${job.params.resourceId} not found`);
+    }
+    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
+    );
+    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);
+      }
+    }
+    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/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.metadata.type === "comment-detection";
+  }
+  async executeJob(job) {
+    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);
+  }
+  /**
+   * Override updateJobProgress to emit events to Event Store
+   */
+  async updateJobProgress(job) {
+    await super.updateJobProgress(job);
+    if (job.metadata.type !== "comment-detection") return;
+    if (job.status !== "running") {
+      return;
+    }
+    const cdJob = job;
+    const baseEvent = {
+      resourceId: cdJob.params.resourceId,
+      userId: cdJob.metadata.userId,
+      version: 1
+    };
+    const isComplete = cdJob.progress.percentage === 100;
+    if (this.isFirstProgress) {
+      this.isFirstProgress = false;
+      await this.eventStore.appendEvent({
+        type: "job.started",
+        ...baseEvent,
+        payload: {
+          jobId: cdJob.metadata.id,
+          jobType: cdJob.metadata.type
+        }
+      });
+    } else if (isComplete) {
+      await this.eventStore.appendEvent({
+        type: "job.completed",
+        ...baseEvent,
+        payload: {
+          jobId: cdJob.metadata.id,
+          jobType: cdJob.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: cdJob.metadata.id,
+          jobType: cdJob.metadata.type,
+          progress: cdJob.progress
+        }
+      });
+    }
+  }
+  async handleJobFailure(job, error) {
+    await super.handleJobFailure(job, error);
+    if (job.status === "failed" && job.metadata.type === "comment-detection") {
+      const cdJob = job;
+      await this.eventStore.appendEvent({
+        type: "job.failed",
+        resourceId: cdJob.params.resourceId,
+        userId: cdJob.metadata.userId,
+        version: 1,
+        payload: {
+          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.params.resourceId} (job: ${job.metadata.id})`);
+    const resource = await ResourceContext.getResourceMetadata(job.params.resourceId, this.config);
+    if (!resource) {
+      throw new Error(`Resource ${job.params.resourceId} not found`);
+    }
+    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 and generating comments..."
+      }
+    };
+    await this.updateJobProgress(updatedJob);
+    const comments = await AnnotationDetection.detectComments(
+      job.params.resourceId,
+      this.config,
+      this.inferenceClient,
+      job.params.instructions,
+      job.params.tone,
+      job.params.density
+    );
+    console.log(`[CommentDetectionWorker] Found ${comments.length} comments to create`);
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 60,
+        message: `Creating ${comments.length} annotations...`
+      }
+    };
+    await this.updateJobProgress(updatedJob);
+    let created = 0;
+    for (const comment of comments) {
+      try {
+        await this.createCommentAnnotation(job.params.resourceId, job.metadata.userId, comment);
+        created++;
+      } catch (error) {
+        console.error(`[CommentDetectionWorker] Failed to create comment:`, error);
+      }
+    }
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 100,
+        message: `Complete! Created ${created} comments`
+      }
+    };
+    await this.updateJobProgress(updatedJob);
+    console.log(`[CommentDetectionWorker] \u2705 Created ${created}/${comments.length} comments`);
+  }
+  async createCommentAnnotation(resourceId2, userId_, comment) {
+    const backendUrl = this.config.services.backend?.publicURL;
+    if (!backendUrl) {
+      throw new Error("Backend publicURL not configured");
+    }
+    const resourceUri3 = resourceIdToURI4(resourceId2, backendUrl);
+    const annotationId2 = generateAnnotationId4(backendUrl);
+    const annotation = {
+      "@context": "http://www.w3.org/ns/anno.jsonld",
+      type: "Annotation",
+      id: annotationId2,
+      motivation: "commenting",
+      target: {
+        type: "SpecificResource",
+        source: resourceUri3,
+        selector: [
+          {
+            type: "TextPositionSelector",
+            start: comment.start,
+            end: comment.end
+          },
+          {
+            type: "TextQuoteSelector",
+            exact: comment.exact,
+            prefix: comment.prefix || "",
+            suffix: comment.suffix || ""
+          }
+        ]
+      },
+      body: [
+        {
+          type: "TextualBody",
+          value: comment.comment,
+          purpose: "commenting",
+          format: "text/plain",
+          language: "en"
+        }
+      ]
+    };
+    await this.eventStore.appendEvent({
+      type: "annotation.added",
+      resourceId: resourceId2,
+      userId: userId3(userId_),
+      version: 1,
+      payload: {
+        annotation
+      }
+    });
+    console.log(`[CommentDetectionWorker] Created comment annotation ${annotationId2} for "${comment.exact.substring(0, 50)}..."`);
+  }
+};
+
+// 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 "TagDetectionWorker";
+  }
+  canProcessJob(job) {
+    return job.metadata.type === "tag-detection";
+  }
+  async executeJob(job) {
+    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.processTagDetectionJob(job);
+  }
+  /**
+   * Override updateJobProgress to emit events to Event Store
+   */
+  async updateJobProgress(job) {
+    await super.updateJobProgress(job);
+    if (job.metadata.type !== "tag-detection") return;
+    if (job.status !== "running") {
+      return;
+    }
+    const tdJob = job;
+    const baseEvent = {
+      resourceId: tdJob.params.resourceId,
+      userId: tdJob.metadata.userId,
+      version: 1
+    };
+    const isComplete = tdJob.progress.percentage === 100;
+    if (this.isFirstProgress) {
+      this.isFirstProgress = false;
+      await this.eventStore.appendEvent({
+        type: "job.started",
+        ...baseEvent,
+        payload: {
+          jobId: tdJob.metadata.id,
+          jobType: tdJob.metadata.type
+        }
+      });
+    } else if (isComplete) {
+      await this.eventStore.appendEvent({
+        type: "job.completed",
+        ...baseEvent,
+        payload: {
+          jobId: tdJob.metadata.id,
+          jobType: tdJob.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: tdJob.metadata.id,
+          jobType: tdJob.metadata.type,
+          progress: tdJob.progress
+        }
+      });
+    }
+  }
+  async handleJobFailure(job, error) {
+    await super.handleJobFailure(job, error);
+    if (job.status === "failed" && job.metadata.type === "tag-detection") {
+      const tdJob = job;
+      await this.eventStore.appendEvent({
+        type: "job.failed",
+        resourceId: tdJob.params.resourceId,
+        userId: tdJob.metadata.userId,
+        version: 1,
+        payload: {
+          jobId: tdJob.metadata.id,
+          jobType: tdJob.metadata.type,
+          error: "Tag detection failed. Please try again later."
+        }
+      });
+    }
+  }
+  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.params.resourceId} not found`);
+    }
+    let updatedJob = {
+      ...job,
+      progress: {
+        stage: "analyzing",
+        percentage: 10,
+        processedCategories: 0,
+        totalCategories: job.params.categories.length,
+        message: "Loading resource..."
+      }
+    };
+    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(updatedJob);
+    let created = 0;
+    for (const tag of allTags) {
+      try {
+        await this.createTagAnnotation(job.params.resourceId, job.metadata.userId, job.params.schemaId, tag);
+        created++;
+      } catch (error) {
+        console.error(`[TagDetectionWorker] Failed to create tag:`, error);
+      }
+    }
+    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(updatedJob);
+    console.log(`[TagDetectionWorker] \u2705 Created ${created}/${allTags.length} tags across ${job.params.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");
+    }
+    const resourceUri3 = resourceIdToURI5(resourceId2, backendUrl);
+    const annotationId2 = generateAnnotationId5(backendUrl);
+    const annotation = {
+      "@context": "http://www.w3.org/ns/anno.jsonld",
+      type: "Annotation",
+      id: annotationId2,
+      motivation: "tagging",
+      target: {
+        type: "SpecificResource",
+        source: resourceUri3,
+        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"
+        }
+      ]
+    };
+    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/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;
+  }
+  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();
+  }
+  /**
+   * 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");
+  }
+  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 } from "@semiont/content";
-import { getPrimaryRepresentation, decodeRepresentation } from "@semiont/api-client";
+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(resourceId, config) {
+  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(resourceId);
+    const view = await viewStorage.get(resourceId2);
     if (!view) {
       return null;
     }
@@ -52,14 +2147,14 @@ var ResourceContext = class {
   static async addContentPreviews(resources, config) {
     const basePath = config.services.filesystem.path;
     const projectRoot = config._metadata?.projectRoot;
-    const repStore = new FilesystemRepresentationStore({ basePath }, projectRoot);
+    const repStore = new FilesystemRepresentationStore4({ basePath }, projectRoot);
     return await Promise.all(
       resources.map(async (doc) => {
         try {
-          const primaryRep = getPrimaryRepresentation(doc);
+          const primaryRep = getPrimaryRepresentation2(doc);
           if (primaryRep?.checksum && primaryRep?.mediaType) {
             const contentBuffer = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
-            const contentPreview = decodeRepresentation(contentBuffer, primaryRep.mediaType).slice(0, 200);
+            const contentPreview = decodeRepresentation2(contentBuffer, primaryRep.mediaType).slice(0, 200);
             return { ...doc, content: contentPreview };
           }
           return { ...doc, content: "" };
@@ -72,20 +2167,20 @@ var ResourceContext = class {
 };
 
 // src/annotation-context.ts
-import { generateResourceSummary, generateText } from "@semiont/inference";
+import { getInferenceClient as getInferenceClient2 } from "@semiont/inference";
 import {
   getBodySource,
   getTargetSource,
-  getTargetSelector,
+  getTargetSelector as getTargetSelector2,
   getResourceEntityTypes,
   getTextPositionSelector,
-  getPrimaryRepresentation as getPrimaryRepresentation2,
-  decodeRepresentation as decodeRepresentation2
+  getPrimaryRepresentation as getPrimaryRepresentation3,
+  decodeRepresentation as decodeRepresentation3
 } from "@semiont/api-client";
-import { FilesystemRepresentationStore as FilesystemRepresentationStore2 } from "@semiont/content";
+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 } from "@semiont/ontology";
+import { getEntityTypes as getEntityTypes2 } from "@semiont/ontology";
 var AnnotationContext = class {
   /**
    * Build LLM context for an annotation
@@ -97,7 +2192,7 @@ var AnnotationContext = class {
    * @returns Rich context for LLM processing
    * @throws Error if annotation or resource not found
    */
-  static async buildLLMContext(annotationUri, resourceId, config, options = {}) {
+  static async buildLLMContext(annotationUri2, resourceId2, config, options = {}) {
     const {
       includeSourceContext = true,
       includeTargetContext = true,
@@ -106,16 +2201,16 @@ var AnnotationContext = class {
     if (contextWindow < 100 || contextWindow > 5e3) {
       throw new Error("contextWindow must be between 100 and 5000");
     }
-    console.log(`[AnnotationContext] buildLLMContext called with annotationUri=${annotationUri}, resourceId=${resourceId}`);
+    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=${resourceId}`);
+    const repStore = new FilesystemRepresentationStore5({ basePath }, projectRoot);
+    console.log(`[AnnotationContext] Getting view for resourceId=${resourceId2}`);
     let sourceView;
     try {
-      sourceView = await viewStorage.get(resourceId);
+      sourceView = await viewStorage.get(resourceId2);
       console.log(`[AnnotationContext] Got view:`, !!sourceView);
       if (!sourceView) {
         throw new Error("Source resource not found");
@@ -124,19 +2219,19 @@ var AnnotationContext = class {
       console.error(`[AnnotationContext] Error getting view:`, error);
       throw error;
     }
-    console.log(`[AnnotationContext] Looking for annotation ${annotationUri} in resource ${resourceId}`);
+    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 === annotationUri);
+    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: ${resourceId}, Extracted ID: ${targetResourceId}`);
-    if (targetResourceId !== resourceId) {
-      throw new Error(`Annotation target resource ID (${targetResourceId}) does not match expected resource ID (${resourceId})`);
+    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);
@@ -153,13 +2248,13 @@ var AnnotationContext = class {
     }
     let sourceContext;
     if (includeSourceContext) {
-      const primaryRep = getPrimaryRepresentation2(sourceDoc);
+      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 = decodeRepresentation2(sourceContent, primaryRep.mediaType);
-      const targetSelectorRaw = getTargetSelector(annotation.target);
+      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) {
@@ -194,13 +2289,14 @@ var AnnotationContext = class {
     }
     let targetContext;
     if (includeTargetContext && targetDoc) {
-      const targetRep = getPrimaryRepresentation2(targetDoc);
+      const targetRep = getPrimaryRepresentation3(targetDoc);
       if (targetRep?.checksum && targetRep?.mediaType) {
         const targetContent = await repStore.retrieve(targetRep.checksum, targetRep.mediaType);
-        const contentStr = decodeRepresentation2(targetContent, 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), config)
+          summary: await generateResourceSummary(targetDoc.name, contentStr, getResourceEntityTypes(targetDoc), client)
         };
       }
     }
@@ -214,7 +2310,7 @@ var AnnotationContext = class {
       metadata: {
         resourceType: "document",
         language: sourceDoc.language,
-        entityTypes: getEntityTypes(annotation)
+        entityTypes: getEntityTypes2(annotation)
       }
     } : void 0;
     const response = {
@@ -233,16 +2329,16 @@ var AnnotationContext = class {
    * Get resource annotations from view storage (fast path)
    * Throws if view missing
    */
-  static async getResourceAnnotations(resourceId, config) {
+  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(resourceId);
+    const view = await viewStorage.get(resourceId2);
     if (!view) {
-      throw new Error(`Resource ${resourceId} not found in view storage`);
+      throw new Error(`Resource ${resourceId2} not found in view storage`);
     }
     return view.annotations;
   }
@@ -250,8 +2346,8 @@ var AnnotationContext = class {
    * Get all annotations
    * @returns Array of all annotation objects
    */
-  static async getAllAnnotations(resourceId, config) {
-    const annotations = await this.getResourceAnnotations(resourceId, config);
+  static async getAllAnnotations(resourceId2, config) {
+    const annotations = await this.getResourceAnnotations(resourceId2, config);
     return await this.enrichResolvedReferences(annotations.annotations, config);
   }
   /**
@@ -268,7 +2364,7 @@ var AnnotationContext = class {
       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) {
+          if (item.type === "SpecificResource" && item.purpose === "linking" && item.source) {
             resolvedUris.add(item.source);
           }
         }
@@ -309,7 +2405,7 @@ var AnnotationContext = class {
       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) {
+          if (item.type === "SpecificResource" && item.purpose === "linking" && item.source) {
             const metadata = uriToMetadata.get(item.source);
             if (metadata) {
               return {
@@ -328,8 +2424,8 @@ var AnnotationContext = class {
    * Get resource stats (version info)
    * @returns Version and timestamp info for the annotations
    */
-  static async getResourceStats(resourceId, config) {
-    const annotations = await this.getResourceAnnotations(resourceId, config);
+  static async getResourceStats(resourceId2, config) {
+    const annotations = await this.getResourceAnnotations(resourceId2, config);
     return {
       resourceId: annotations.resourceId,
       version: annotations.version,
@@ -339,24 +2435,24 @@ var AnnotationContext = class {
   /**
    * Check if resource exists in view storage
    */
-  static async resourceExists(resourceId, config) {
+  static async resourceExists(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);
-    return await viewStorage.exists(resourceId);
+    return await viewStorage.exists(resourceId2);
   }
   /**
    * Get a single annotation by ID
    * O(1) lookup using resource ID to access view storage
    */
-  static async getAnnotation(annotationId, resourceId, config) {
-    const annotations = await this.getResourceAnnotations(resourceId, config);
+  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 === annotationId;
+      return shortId === annotationId2;
     }) || null;
   }
   /**
@@ -373,11 +2469,11 @@ var AnnotationContext = class {
   /**
    * Get annotation context (selected text with surrounding context)
    */
-  static async getAnnotationContext(annotationId, resourceId, contextBefore, contextAfter, config) {
+  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(annotationId, resourceId, config);
+    const repStore = new FilesystemRepresentationStore5({ basePath }, projectRoot);
+    const annotation = await this.getAnnotation(annotationId2, resourceId2, config);
     if (!annotation) {
       throw new Error("Annotation not found");
     }
@@ -409,11 +2505,11 @@ var AnnotationContext = class {
   /**
    * Generate AI summary of annotation in context
    */
-  static async generateAnnotationSummary(annotationId, resourceId, config) {
+  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(annotationId, resourceId, config);
+    const repStore = new FilesystemRepresentationStore5({ basePath }, projectRoot);
+    const annotation = await this.getAnnotation(annotationId2, resourceId2, config);
     if (!annotation) {
       throw new Error("Annotation not found");
     }
@@ -427,7 +2523,7 @@ var AnnotationContext = class {
     const contentStr = await this.getResourceContent(resource, repStore);
     const contextSize = 500;
     const context = this.extractAnnotationContext(annotation, contentStr, contextSize, contextSize);
-    const annotationEntityTypes = getEntityTypes(annotation);
+    const annotationEntityTypes = getEntityTypes2(annotation);
     const summary = await this.generateSummary(resource, context, annotationEntityTypes, config);
     return {
       summary,
@@ -449,18 +2545,18 @@ var AnnotationContext = class {
    * Get resource content as string
    */
   static async getResourceContent(resource, repStore) {
-    const primaryRep = getPrimaryRepresentation2(resource);
+    const primaryRep = getPrimaryRepresentation3(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);
+    return decodeRepresentation3(content, primaryRep.mediaType);
   }
   /**
    * Extract annotation context from resource content
    */
   static extractAnnotationContext(annotation, contentStr, contextBefore, contextAfter) {
-    const targetSelector = getTargetSelector(annotation.target);
+    const targetSelector = getTargetSelector2(annotation.target);
     const posSelector = targetSelector ? getTextPositionSelector(targetSelector) : null;
     if (!posSelector) {
       throw new Error("TextPositionSelector required for context");
@@ -477,6 +2573,7 @@ var AnnotationContext = class {
   }
   /**
    * 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:
@@ -487,82 +2584,564 @@ Context after: "${context.after.substring(0, 200)}"
 
 Resource: ${resource.name}
 Entity types: ${entityTypes.join(", ")}`;
-    return await generateText(summaryPrompt, config, 500, 0.5);
+    const client = await getInferenceClient2(config);
+    return await client.generateText(summaryPrompt, 500, 0.5);
   }
 };
 
 // src/graph-context.ts
-import { getGraphDatabase } from "@semiont/graph";
-import { resourceIdToURI } from "@semiont/core";
+import { getGraphDatabase as getGraphDatabase2 } from "@semiont/graph";
+import { resourceIdToURI as resourceIdToURI6 } from "@semiont/core";
 var GraphContext = class {
   /**
    * Get all resources referencing this resource (backlinks)
    * Requires graph traversal - must use graph database
    */
-  static async getBacklinks(resourceId, config) {
-    const graphDb = await getGraphDatabase(config);
-    const resourceUri = resourceIdToURI(resourceId, config.services.backend.publicURL);
-    return await graphDb.getResourceReferencedBy(resourceUri);
+  static async getBacklinks(resourceId2, config) {
+    const graphDb = await getGraphDatabase2(config);
+    const resourceUri3 = resourceIdToURI6(resourceId2, config.services.backend.publicURL);
+    return await graphDb.getResourceReferencedBy(resourceUri3);
   }
   /**
    * 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);
+    const graphDb = await getGraphDatabase2(config);
     return await graphDb.findPath(fromResourceId, toResourceId, maxDepth);
   }
   /**
    * Get resource connections (graph edges)
    * Requires graph traversal - must use graph database
    */
-  static async getResourceConnections(resourceId, config) {
-    const graphDb = await getGraphDatabase(config);
-    return await graphDb.getResourceConnections(resourceId);
+  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 getGraphDatabase(config);
+    const graphDb = await getGraphDatabase2(config);
     return await graphDb.searchResources(query, limit);
   }
 };
 
 // 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";
+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;
+  }
+  /**
+   * 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."}
+]`;
+    }
+    return prompt;
+  }
+  /**
+   * Build a prompt for detecting structural tags
+   *
+   * @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
+   */
+  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 = 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(`[MotivationParsers] Skipping invalid comment "${comment.exact}":`, error);
+        }
+      }
+      return validatedComments;
+    } catch (error) {
+      console.error("[MotivationParsers] Failed to parse AI comment response:", error);
+      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 {
+          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
+          });
+        } catch (error) {
+          console.warn(`[MotivationParsers] Skipping invalid highlight "${highlight.exact}":`, error);
+        }
+      }
+      return validatedHighlights;
+    } catch (error) {
+      console.error("[MotivationParsers] Failed to parse AI highlight response:", error);
+      console.error("Raw response:", response);
+      return [];
+    }
+  }
+  /**
+   * 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
+   */
+  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);
+        }
+      }
+      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 [];
+    }
+  }
+  /**
+   * 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 [];
+    }
+  }
+  /**
+   * 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;
+  }
+};
+
+// 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(resourceId, config, instructions, tone, density) {
-    const resource = await ResourceContext.getResourceMetadata(resourceId, config);
+  static async detectComments(resourceId2, config, client, instructions, tone, density) {
+    const resource = await ResourceContext.getResourceMetadata(resourceId2, config);
     if (!resource) {
-      throw new Error(`Resource ${resourceId} not found`);
+      throw new Error(`Resource ${resourceId2} not found`);
     }
-    const content = await this.loadResourceContent(resourceId, config);
+    const content = await this.loadResourceContent(resourceId2, config);
     if (!content) {
-      throw new Error(`Could not load content for resource ${resourceId}`);
+      throw new Error(`Could not load content for resource ${resourceId2}`);
     }
     const prompt = MotivationPrompts.buildCommentPrompt(content, instructions, tone, density);
-    const response = await generateText2(
+    const response = await client.generateText(
       prompt,
-      config,
       3e3,
       // maxTokens: Higher than highlights/assessments due to comment text
       0.4
@@ -575,23 +3154,23 @@ var AnnotationDetection = class {
    *
    * @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(resourceId, config, instructions, density) {
-    const resource = await ResourceContext.getResourceMetadata(resourceId, config);
+  static async detectHighlights(resourceId2, config, client, instructions, density) {
+    const resource = await ResourceContext.getResourceMetadata(resourceId2, config);
     if (!resource) {
-      throw new Error(`Resource ${resourceId} not found`);
+      throw new Error(`Resource ${resourceId2} not found`);
     }
-    const content = await this.loadResourceContent(resourceId, config);
+    const content = await this.loadResourceContent(resourceId2, config);
     if (!content) {
-      throw new Error(`Could not load content for resource ${resourceId}`);
+      throw new Error(`Could not load content for resource ${resourceId2}`);
     }
     const prompt = MotivationPrompts.buildHighlightPrompt(content, instructions, density);
-    const response = await generateText2(
+    const response = await client.generateText(
       prompt,
-      config,
       2e3,
       // maxTokens: Lower than comments/assessments (no body text)
       0.3
@@ -604,24 +3183,24 @@ var AnnotationDetection = class {
    *
    * @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(resourceId, config, instructions, tone, density) {
-    const resource = await ResourceContext.getResourceMetadata(resourceId, config);
+  static async detectAssessments(resourceId2, config, client, instructions, tone, density) {
+    const resource = await ResourceContext.getResourceMetadata(resourceId2, config);
     if (!resource) {
-      throw new Error(`Resource ${resourceId} not found`);
+      throw new Error(`Resource ${resourceId2} not found`);
     }
-    const content = await this.loadResourceContent(resourceId, config);
+    const content = await this.loadResourceContent(resourceId2, config);
     if (!content) {
-      throw new Error(`Could not load content for resource ${resourceId}`);
+      throw new Error(`Could not load content for resource ${resourceId2}`);
     }
     const prompt = MotivationPrompts.buildAssessmentPrompt(content, instructions, tone, density);
-    const response = await generateText2(
+    const response = await client.generateText(
       prompt,
-      config,
       3e3,
       // maxTokens: Higher for assessment text
       0.3
@@ -634,12 +3213,13 @@ var AnnotationDetection = class {
    *
    * @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(resourceId, config, schemaId, category) {
-    const schema = getTagSchema(schemaId);
+  static async detectTags(resourceId2, config, client, schemaId, category) {
+    const schema = getTagSchema2(schemaId);
     if (!schema) {
       throw new Error(`Invalid tag schema: ${schemaId}`);
     }
@@ -647,13 +3227,13 @@ var AnnotationDetection = class {
     if (!categoryInfo) {
       throw new Error(`Invalid category "${category}" for schema ${schemaId}`);
     }
-    const resource = await ResourceContext.getResourceMetadata(resourceId, config);
+    const resource = await ResourceContext.getResourceMetadata(resourceId2, config);
     if (!resource) {
-      throw new Error(`Resource ${resourceId} not found`);
+      throw new Error(`Resource ${resourceId2} not found`);
     }
-    const content = await this.loadResourceContent(resourceId, config);
+    const content = await this.loadResourceContent(resourceId2, config);
     if (!content) {
-      throw new Error(`Could not load content for resource ${resourceId}`);
+      throw new Error(`Could not load content for resource ${resourceId2}`);
     }
     const prompt = MotivationPrompts.buildTagPrompt(
       content,
@@ -664,9 +3244,8 @@ var AnnotationDetection = class {
       categoryInfo.description,
       categoryInfo.examples
     );
-    const response = await generateText2(
+    const response = await client.generateText(
       prompt,
-      config,
       4e3,
       // maxTokens: Higher for full document analysis
       0.2
@@ -683,10 +3262,10 @@ var AnnotationDetection = class {
    * @param config - Environment configuration
    * @returns Resource content as string, or null if not available
    */
-  static async loadResourceContent(resourceId, config) {
-    const resource = await ResourceContext.getResourceMetadata(resourceId, config);
+  static async loadResourceContent(resourceId2, config) {
+    const resource = await ResourceContext.getResourceMetadata(resourceId2, config);
     if (!resource) return null;
-    const primaryRep = getPrimaryRepresentation3(resource);
+    const primaryRep = getPrimaryRepresentation4(resource);
     if (!primaryRep) return null;
     const baseMediaType = primaryRep.mediaType?.split(";")[0]?.trim() || "";
     if (baseMediaType !== "text/plain" && baseMediaType !== "text/markdown") {
@@ -695,9 +3274,9 @@ var AnnotationDetection = class {
     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 repStore = new FilesystemRepresentationStore6({ basePath }, projectRoot);
     const contentBuffer = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
-    return decodeRepresentation3(contentBuffer, primaryRep.mediaType);
+    return decodeRepresentation4(contentBuffer, primaryRep.mediaType);
   }
 };
 
@@ -707,9 +3286,23 @@ var VERSION = "0.1.0";
 export {
   AnnotationContext,
   AnnotationDetection,
+  AssessmentDetectionWorker,
+  CommentDetectionWorker,
+  GenerationWorker,
   GraphContext,
+  GraphDBConsumer,
+  HighlightDetectionWorker,
+  MotivationParsers,
+  MotivationPrompts,
   PACKAGE_NAME,
+  ReferenceDetectionWorker,
   ResourceContext,
-  VERSION
+  TagDetectionWorker,
+  VERSION,
+  extractEntities,
+  generateReferenceSuggestions,
+  generateResourceFromTopic,
+  generateResourceSummary,
+  startMakeMeaning
 };
 //# sourceMappingURL=index.js.map