@semiont/make-meaning 0.2.30-build.60 → 0.2.30-build.62

package/dist/index.js

@@ -6,11 +6,11 @@ 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;
     }
@@ -97,7 +97,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 +106,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}`);
+    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 +124,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);
@@ -233,16 +233,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 +250,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);
   }
   /**
@@ -328,8 +328,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 +339,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 +373,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 annotation = await this.getAnnotation(annotationId2, resourceId2, config);
     if (!annotation) {
       throw new Error("Annotation not found");
     }
@@ -409,11 +409,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 annotation = await this.getAnnotation(annotationId2, resourceId2, config);
     if (!annotation) {
       throw new Error("Annotation not found");
     }
@@ -499,10 +499,10 @@ var GraphContext = class {
    * Get all resources referencing this resource (backlinks)
    * Requires graph traversal - must use graph database
    */
-  static async getBacklinks(resourceId, config) {
+  static async getBacklinks(resourceId2, config) {
     const graphDb = await getGraphDatabase(config);
-    const resourceUri = resourceIdToURI(resourceId, config.services.backend.publicURL);
-    return await graphDb.getResourceReferencedBy(resourceUri);
+    const resourceUri2 = resourceIdToURI(resourceId2, config.services.backend.publicURL);
+    return await graphDb.getResourceReferencedBy(resourceUri2);
   }
   /**
    * Find shortest path between two resources
@@ -516,9 +516,9 @@ var GraphContext = class {
    * Get resource connections (graph edges)
    * Requires graph traversal - must use graph database
    */
-  static async getResourceConnections(resourceId, config) {
+  static async getResourceConnections(resourceId2, config) {
     const graphDb = await getGraphDatabase(config);
-    return await graphDb.getResourceConnections(resourceId);
+    return await graphDb.getResourceConnections(resourceId2);
   }
   /**
    * Search resources by name (cross-resource query)
@@ -550,14 +550,14 @@ var AnnotationDetection = class {
    * @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, 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(
@@ -579,14 +579,14 @@ var AnnotationDetection = class {
    * @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, 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(
@@ -609,14 +609,14 @@ var AnnotationDetection = class {
    * @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, 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(
@@ -638,7 +638,7 @@ var AnnotationDetection = class {
    * @param category - The specific category to detect
    * @returns Array of validated tag matches
    */
-  static async detectTags(resourceId, config, schemaId, category) {
+  static async detectTags(resourceId2, config, schemaId, category) {
     const schema = getTagSchema(schemaId);
     if (!schema) {
       throw new Error(`Invalid tag schema: ${schemaId}`);
@@ -647,13 +647,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,
@@ -683,8 +683,8 @@ 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);
     if (!primaryRep) return null;
@@ -701,15 +701,1371 @@ var AnnotationDetection = class {
   }
 };
 
+// src/jobs/workers/comment-detection-worker.ts
+import { JobWorker } from "@semiont/jobs";
+import { generateAnnotationId } from "@semiont/event-sourcing";
+import { resourceIdToURI as resourceIdToURI2 } from "@semiont/core";
+import { userId } from "@semiont/core";
+var CommentDetectionWorker = class extends JobWorker {
+  constructor(jobQueue, config, eventStore) {
+    super(jobQueue);
+    this.config = config;
+    this.eventStore = eventStore;
+  }
+  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,
+      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 resourceUri2 = resourceIdToURI2(resourceId2, backendUrl);
+    const annotationId2 = generateAnnotationId(backendUrl);
+    const annotation = {
+      "@context": "http://www.w3.org/ns/anno.jsonld",
+      type: "Annotation",
+      id: annotationId2,
+      motivation: "commenting",
+      target: {
+        type: "SpecificResource",
+        source: resourceUri2,
+        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: userId(userId_),
+      version: 1,
+      payload: {
+        annotation
+      }
+    });
+    console.log(`[CommentDetectionWorker] Created comment annotation ${annotationId2} for "${comment.exact.substring(0, 50)}..."`);
+  }
+};
+
+// src/jobs/workers/highlight-detection-worker.ts
+import { JobWorker as JobWorker2 } from "@semiont/jobs";
+import { generateAnnotationId as generateAnnotationId2 } from "@semiont/event-sourcing";
+import { resourceIdToURI as resourceIdToURI3 } from "@semiont/core";
+import { userId as userId2 } from "@semiont/core";
+var HighlightDetectionWorker = class extends JobWorker2 {
+  constructor(jobQueue, config, eventStore) {
+    super(jobQueue);
+    this.config = config;
+    this.eventStore = eventStore;
+  }
+  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,
+      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 resourceUri2 = resourceIdToURI3(resourceId2, backendUrl);
+    const annotation = {
+      "@context": "http://www.w3.org/ns/anno.jsonld",
+      "type": "Annotation",
+      "id": annotationId2,
+      "motivation": "highlighting",
+      "creator": userId2(creatorUserId),
+      "created": (/* @__PURE__ */ new Date()).toISOString(),
+      "target": {
+        type: "SpecificResource",
+        source: resourceUri2,
+        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: userId2(creatorUserId),
+      version: 1,
+      payload: { annotation }
+    });
+  }
+};
+
+// src/jobs/workers/assessment-detection-worker.ts
+import { JobWorker as JobWorker3 } from "@semiont/jobs";
+import { generateAnnotationId as generateAnnotationId3 } from "@semiont/event-sourcing";
+import { resourceIdToURI as resourceIdToURI4 } from "@semiont/core";
+import { userId as userId3 } from "@semiont/core";
+var AssessmentDetectionWorker = class extends JobWorker3 {
+  constructor(jobQueue, config, eventStore) {
+    super(jobQueue);
+    this.config = config;
+    this.eventStore = eventStore;
+  }
+  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,
+      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 resourceUri2 = resourceIdToURI4(resourceId2, backendUrl);
+    const annotation = {
+      "@context": "http://www.w3.org/ns/anno.jsonld",
+      "type": "Annotation",
+      "id": annotationId2,
+      "motivation": "assessing",
+      "creator": userId3(creatorUserId),
+      "created": (/* @__PURE__ */ new Date()).toISOString(),
+      "target": {
+        type: "SpecificResource",
+        source: resourceUri2,
+        selector: [
+          {
+            type: "TextPositionSelector",
+            start: assessment.start,
+            end: assessment.end
+          },
+          {
+            type: "TextQuoteSelector",
+            exact: assessment.exact,
+            ...assessment.prefix && { prefix: assessment.prefix },
+            ...assessment.suffix && { suffix: assessment.suffix }
+          }
+        ]
+      },
+      "body": {
+        type: "TextualBody",
+        value: assessment.assessment,
+        format: "text/plain"
+      }
+    };
+    await this.eventStore.appendEvent({
+      type: "annotation.added",
+      resourceId: resourceId2,
+      userId: userId3(creatorUserId),
+      version: 1,
+      payload: { annotation }
+    });
+  }
+};
+
+// src/jobs/workers/tag-detection-worker.ts
+import { JobWorker as JobWorker4 } from "@semiont/jobs";
+import { generateAnnotationId as generateAnnotationId4 } from "@semiont/event-sourcing";
+import { resourceIdToURI as resourceIdToURI5 } from "@semiont/core";
+import { getTagSchema as getTagSchema2 } from "@semiont/ontology";
+import { userId as userId4 } from "@semiont/core";
+var TagDetectionWorker = class extends JobWorker4 {
+  constructor(jobQueue, config, eventStore) {
+    super(jobQueue);
+    this.config = config;
+    this.eventStore = eventStore;
+  }
+  isFirstProgress = true;
+  getWorkerName() {
+    return "TagDetectionWorker";
+  }
+  canProcessJob(job) {
+    return job.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 = getTagSchema2(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,
+        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 resourceUri2 = resourceIdToURI5(resourceId2, backendUrl);
+    const annotationId2 = generateAnnotationId4(backendUrl);
+    const annotation = {
+      "@context": "http://www.w3.org/ns/anno.jsonld",
+      type: "Annotation",
+      id: annotationId2,
+      motivation: "tagging",
+      target: {
+        type: "SpecificResource",
+        source: resourceUri2,
+        selector: [
+          {
+            type: "TextPositionSelector",
+            start: tag.start,
+            end: tag.end
+          },
+          {
+            type: "TextQuoteSelector",
+            exact: tag.exact,
+            prefix: tag.prefix || "",
+            suffix: tag.suffix || ""
+          }
+        ]
+      },
+      body: [
+        {
+          type: "TextualBody",
+          value: tag.category,
+          purpose: "tagging",
+          format: "text/plain",
+          language: "en"
+        },
+        {
+          type: "TextualBody",
+          value: schemaId,
+          purpose: "classifying",
+          format: "text/plain"
+        }
+      ]
+    };
+    await this.eventStore.appendEvent({
+      type: "annotation.added",
+      resourceId: resourceId2,
+      userId: userId4(userId_),
+      version: 1,
+      payload: {
+        annotation
+      }
+    });
+    console.log(`[TagDetectionWorker] Created tag annotation ${annotationId2} for "${tag.category}": "${tag.exact.substring(0, 50)}..."`);
+  }
+};
+
+// src/jobs/workers/reference-detection-worker.ts
+import { JobWorker as JobWorker5 } from "@semiont/jobs";
+import { generateAnnotationId as generateAnnotationId5 } from "@semiont/event-sourcing";
+import { resourceIdToURI as resourceIdToURI6 } from "@semiont/core";
+import {
+  getPrimaryRepresentation as getPrimaryRepresentation4,
+  decodeRepresentation as decodeRepresentation4,
+  validateAndCorrectOffsets
+} from "@semiont/api-client";
+import { extractEntities } from "@semiont/inference";
+import { FilesystemRepresentationStore as FilesystemRepresentationStore4 } from "@semiont/content";
+var ReferenceDetectionWorker = class extends JobWorker5 {
+  constructor(jobQueue, config, eventStore) {
+    super(jobQueue);
+    this.config = config;
+    this.eventStore = eventStore;
+  }
+  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 = getPrimaryRepresentation4(resource);
+    if (!primaryRep) return detectedAnnotations;
+    const mediaType = primaryRep.mediaType;
+    const baseMediaType = mediaType?.split(";")[0]?.trim() || "";
+    if (baseMediaType === "text/plain" || baseMediaType === "text/markdown") {
+      if (!primaryRep.checksum || !primaryRep.mediaType) return detectedAnnotations;
+      const basePath = this.config.services.filesystem.path;
+      const projectRoot = this.config._metadata?.projectRoot;
+      const repStore = new FilesystemRepresentationStore4({ basePath }, projectRoot);
+      const contentBuffer = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
+      const content = decodeRepresentation4(contentBuffer, primaryRep.mediaType);
+      const extractedEntities = await extractEntities(content, entityTypes, this.config, includeDescriptiveReferences);
+      for (const entity of extractedEntities) {
+        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 = generateAnnotationId5(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: resourceIdToURI6(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/workers/generation-worker.ts
+import { JobWorker as JobWorker6 } from "@semiont/jobs";
+import { FilesystemRepresentationStore as FilesystemRepresentationStore5 } from "@semiont/content";
+import { generateResourceFromTopic } from "@semiont/inference";
+import {
+  getTargetSelector as getTargetSelector2,
+  getExactText,
+  resourceUri,
+  annotationUri
+} from "@semiont/api-client";
+import { getEntityTypes as getEntityTypes2 } from "@semiont/ontology";
+import {
+  CREATION_METHODS,
+  generateUuid,
+  resourceId,
+  annotationId
+} from "@semiont/core";
+var GenerationWorker = class extends JobWorker6 {
+  constructor(jobQueue, config, eventStore) {
+    super(jobQueue);
+    this.config = config;
+    this.eventStore = eventStore;
+  }
+  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 FilesystemRepresentationStore5({ 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 = getTargetSelector2(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 = getEntityTypes2({ body: annotation.body });
+    const generatedContent = await generateResourceFromTopic(
+      resourceName,
+      job.params.entityTypes || annotationEntityTypes,
+      this.config,
+      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/index.ts
 var PACKAGE_NAME = "@semiont/make-meaning";
 var VERSION = "0.1.0";
 export {
   AnnotationContext,
   AnnotationDetection,
+  AssessmentDetectionWorker,
+  CommentDetectionWorker,
+  GenerationWorker,
   GraphContext,
+  HighlightDetectionWorker,
   PACKAGE_NAME,
+  ReferenceDetectionWorker,
   ResourceContext,
+  TagDetectionWorker,
   VERSION
 };
 //# sourceMappingURL=index.js.map