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

package/dist/index.js

@@ -717,11 +717,14 @@ var CommentDetectionWorker = class extends JobWorker {
     return "CommentDetectionWorker";
   }
   canProcessJob(job) {
-    return job.type === "comment-detection";
+    return job.metadata.type === "comment-detection";
   }
   async executeJob(job) {
-    if (job.type !== "comment-detection") {
-      throw new Error(`Invalid job type: ${job.type}`);
+    if (job.metadata.type !== "comment-detection") {
+      throw new Error(`Invalid job type: ${job.metadata.type}`);
+    }
+    if (job.status !== "running") {
+      throw new Error(`Job must be in running state to execute, got: ${job.status}`);
     }
     this.isFirstProgress = true;
     await this.processCommentDetectionJob(job);
@@ -731,23 +734,25 @@ var CommentDetectionWorker = class extends JobWorker {
    */
   async updateJobProgress(job) {
     await super.updateJobProgress(job);
-    if (job.type !== "comment-detection") return;
+    if (job.metadata.type !== "comment-detection") return;
+    if (job.status !== "running") {
+      return;
+    }
     const cdJob = job;
-    if (!cdJob.progress) return;
     const baseEvent = {
-      resourceId: cdJob.resourceId,
-      userId: cdJob.userId,
+      resourceId: cdJob.params.resourceId,
+      userId: cdJob.metadata.userId,
       version: 1
     };
-    const isComplete = cdJob.progress.percentage === 100 && cdJob.result;
+    const isComplete = cdJob.progress.percentage === 100;
     if (this.isFirstProgress) {
       this.isFirstProgress = false;
       await this.eventStore.appendEvent({
         type: "job.started",
         ...baseEvent,
         payload: {
-          jobId: cdJob.id,
-          jobType: cdJob.type
+          jobId: cdJob.metadata.id,
+          jobType: cdJob.metadata.type
         }
       });
     } else if (isComplete) {
@@ -755,9 +760,9 @@ var CommentDetectionWorker = class extends JobWorker {
         type: "job.completed",
         ...baseEvent,
         payload: {
-          jobId: cdJob.id,
-          jobType: cdJob.type,
-          result: cdJob.result
+          jobId: cdJob.metadata.id,
+          jobType: cdJob.metadata.type
+          // Note: result would come from job.result, but that's handled by base class
         }
       });
     } else {
@@ -765,8 +770,8 @@ var CommentDetectionWorker = class extends JobWorker {
         type: "job.progress",
         ...baseEvent,
         payload: {
-          jobId: cdJob.id,
-          jobType: cdJob.type,
+          jobId: cdJob.metadata.id,
+          jobType: cdJob.metadata.type,
           progress: cdJob.progress
         }
       });
@@ -774,72 +779,80 @@ var CommentDetectionWorker = class extends JobWorker {
   }
   async handleJobFailure(job, error) {
     await super.handleJobFailure(job, error);
-    if (job.status === "failed" && job.type === "comment-detection") {
+    if (job.status === "failed" && job.metadata.type === "comment-detection") {
       const cdJob = job;
       await this.eventStore.appendEvent({
         type: "job.failed",
-        resourceId: cdJob.resourceId,
-        userId: cdJob.userId,
+        resourceId: cdJob.params.resourceId,
+        userId: cdJob.metadata.userId,
         version: 1,
         payload: {
-          jobId: cdJob.id,
-          jobType: cdJob.type,
+          jobId: cdJob.metadata.id,
+          jobType: cdJob.metadata.type,
           error: "Comment detection failed. Please try again later."
         }
       });
     }
   }
   async processCommentDetectionJob(job) {
-    console.log(`[CommentDetectionWorker] Processing comment detection for resource ${job.resourceId} (job: ${job.id})`);
-    const resource = await ResourceContext.getResourceMetadata(job.resourceId, this.config);
+    console.log(`[CommentDetectionWorker] Processing comment detection for resource ${job.params.resourceId} (job: ${job.metadata.id})`);
+    const resource = await ResourceContext.getResourceMetadata(job.params.resourceId, this.config);
     if (!resource) {
-      throw new Error(`Resource ${job.resourceId} not found`);
+      throw new Error(`Resource ${job.params.resourceId} not found`);
     }
-    job.progress = {
-      stage: "analyzing",
-      percentage: 10,
-      message: "Loading resource..."
+    let updatedJob = {
+      ...job,
+      progress: {
+        stage: "analyzing",
+        percentage: 10,
+        message: "Loading resource..."
+      }
     };
-    await this.updateJobProgress(job);
-    job.progress = {
-      stage: "analyzing",
-      percentage: 30,
-      message: "Analyzing text and generating comments..."
+    await this.updateJobProgress(updatedJob);
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "analyzing",
+        percentage: 30,
+        message: "Analyzing text and generating comments..."
+      }
     };
-    await this.updateJobProgress(job);
+    await this.updateJobProgress(updatedJob);
     const comments = await AnnotationDetection.detectComments(
-      job.resourceId,
+      job.params.resourceId,
       this.config,
-      job.instructions,
-      job.tone,
-      job.density
+      job.params.instructions,
+      job.params.tone,
+      job.params.density
     );
     console.log(`[CommentDetectionWorker] Found ${comments.length} comments to create`);
-    job.progress = {
-      stage: "creating",
-      percentage: 60,
-      message: `Creating ${comments.length} annotations...`
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 60,
+        message: `Creating ${comments.length} annotations...`
+      }
     };
-    await this.updateJobProgress(job);
+    await this.updateJobProgress(updatedJob);
     let created = 0;
     for (const comment of comments) {
       try {
-        await this.createCommentAnnotation(job.resourceId, job.userId, comment);
+        await this.createCommentAnnotation(job.params.resourceId, job.metadata.userId, comment);
         created++;
       } catch (error) {
         console.error(`[CommentDetectionWorker] Failed to create comment:`, error);
       }
     }
-    job.result = {
-      commentsFound: comments.length,
-      commentsCreated: created
-    };
-    job.progress = {
-      stage: "creating",
-      percentage: 100,
-      message: `Complete! Created ${created} comments`
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 100,
+        message: `Complete! Created ${created} comments`
+      }
     };
-    await this.updateJobProgress(job);
+    await this.updateJobProgress(updatedJob);
     console.log(`[CommentDetectionWorker] \u2705 Created ${created}/${comments.length} comments`);
   }
   async createCommentAnnotation(resourceId2, userId_, comment) {
@@ -910,11 +923,14 @@ var HighlightDetectionWorker = class extends JobWorker2 {
     return "HighlightDetectionWorker";
   }
   canProcessJob(job) {
-    return job.type === "highlight-detection";
+    return job.metadata.type === "highlight-detection";
   }
   async executeJob(job) {
-    if (job.type !== "highlight-detection") {
-      throw new Error(`Invalid job type: ${job.type}`);
+    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);
@@ -924,23 +940,25 @@ var HighlightDetectionWorker = class extends JobWorker2 {
    */
   async updateJobProgress(job) {
     await super.updateJobProgress(job);
-    if (job.type !== "highlight-detection") return;
+    if (job.metadata.type !== "highlight-detection") return;
+    if (job.status !== "running") {
+      return;
+    }
     const hlJob = job;
-    if (!hlJob.progress) return;
     const baseEvent = {
-      resourceId: hlJob.resourceId,
-      userId: hlJob.userId,
+      resourceId: hlJob.params.resourceId,
+      userId: hlJob.metadata.userId,
       version: 1
     };
-    const isComplete = hlJob.progress.percentage === 100 && hlJob.result;
+    const isComplete = hlJob.progress.percentage === 100;
     if (this.isFirstProgress) {
       this.isFirstProgress = false;
       await this.eventStore.appendEvent({
         type: "job.started",
         ...baseEvent,
         payload: {
-          jobId: hlJob.id,
-          jobType: hlJob.type
+          jobId: hlJob.metadata.id,
+          jobType: hlJob.metadata.type
         }
       });
     } else if (isComplete) {
@@ -948,9 +966,9 @@ var HighlightDetectionWorker = class extends JobWorker2 {
         type: "job.completed",
         ...baseEvent,
         payload: {
-          jobId: hlJob.id,
-          jobType: hlJob.type,
-          result: hlJob.result
+          jobId: hlJob.metadata.id,
+          jobType: hlJob.metadata.type
+          // Note: result would come from job.result, but that's handled by base class
         }
       });
     } else {
@@ -958,8 +976,8 @@ var HighlightDetectionWorker = class extends JobWorker2 {
         type: "job.progress",
         ...baseEvent,
         payload: {
-          jobId: hlJob.id,
-          jobType: hlJob.type,
+          jobId: hlJob.metadata.id,
+          jobType: hlJob.metadata.type,
           progress: hlJob.progress
         }
       });
@@ -967,71 +985,79 @@ var HighlightDetectionWorker = class extends JobWorker2 {
   }
   async handleJobFailure(job, error) {
     await super.handleJobFailure(job, error);
-    if (job.status === "failed" && job.type === "highlight-detection") {
+    if (job.status === "failed" && job.metadata.type === "highlight-detection") {
       const hlJob = job;
       await this.eventStore.appendEvent({
         type: "job.failed",
-        resourceId: hlJob.resourceId,
-        userId: hlJob.userId,
+        resourceId: hlJob.params.resourceId,
+        userId: hlJob.metadata.userId,
         version: 1,
         payload: {
-          jobId: hlJob.id,
-          jobType: hlJob.type,
+          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.resourceId} (job: ${job.id})`);
-    const resource = await ResourceContext.getResourceMetadata(job.resourceId, this.config);
+    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.resourceId} not found`);
+      throw new Error(`Resource ${job.params.resourceId} not found`);
     }
-    job.progress = {
-      stage: "analyzing",
-      percentage: 10,
-      message: "Loading resource..."
+    let updatedJob = {
+      ...job,
+      progress: {
+        stage: "analyzing",
+        percentage: 10,
+        message: "Loading resource..."
+      }
     };
-    await this.updateJobProgress(job);
-    job.progress = {
-      stage: "analyzing",
-      percentage: 30,
-      message: "Analyzing text..."
+    await this.updateJobProgress(updatedJob);
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "analyzing",
+        percentage: 30,
+        message: "Analyzing text..."
+      }
     };
-    await this.updateJobProgress(job);
+    await this.updateJobProgress(updatedJob);
     const highlights = await AnnotationDetection.detectHighlights(
-      job.resourceId,
+      job.params.resourceId,
       this.config,
-      job.instructions,
-      job.density
+      job.params.instructions,
+      job.params.density
     );
     console.log(`[HighlightDetectionWorker] Found ${highlights.length} highlights to create`);
-    job.progress = {
-      stage: "creating",
-      percentage: 60,
-      message: `Creating ${highlights.length} annotations...`
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 60,
+        message: `Creating ${highlights.length} annotations...`
+      }
     };
-    await this.updateJobProgress(job);
+    await this.updateJobProgress(updatedJob);
     let created = 0;
     for (const highlight of highlights) {
       try {
-        await this.createHighlightAnnotation(job.resourceId, job.userId, highlight);
+        await this.createHighlightAnnotation(job.params.resourceId, job.metadata.userId, highlight);
         created++;
       } catch (error) {
         console.error(`[HighlightDetectionWorker] Failed to create highlight:`, error);
       }
     }
-    job.result = {
-      highlightsFound: highlights.length,
-      highlightsCreated: created
-    };
-    job.progress = {
-      stage: "creating",
-      percentage: 100,
-      message: `Complete! Created ${created} highlights`
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 100,
+        message: `Complete! Created ${created} highlights`
+      }
     };
-    await this.updateJobProgress(job);
+    await this.updateJobProgress(updatedJob);
     console.log(`[HighlightDetectionWorker] \u2705 Created ${created}/${highlights.length} highlights`);
   }
   async createHighlightAnnotation(resourceId2, creatorUserId, highlight) {
@@ -1092,11 +1118,14 @@ var AssessmentDetectionWorker = class extends JobWorker3 {
     return "AssessmentDetectionWorker";
   }
   canProcessJob(job) {
-    return job.type === "assessment-detection";
+    return job.metadata.type === "assessment-detection";
   }
   async executeJob(job) {
-    if (job.type !== "assessment-detection") {
-      throw new Error(`Invalid job type: ${job.type}`);
+    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);
@@ -1106,23 +1135,25 @@ var AssessmentDetectionWorker = class extends JobWorker3 {
    */
   async updateJobProgress(job) {
     await super.updateJobProgress(job);
-    if (job.type !== "assessment-detection") return;
+    if (job.metadata.type !== "assessment-detection") return;
+    if (job.status !== "running") {
+      return;
+    }
     const assJob = job;
-    if (!assJob.progress) return;
     const baseEvent = {
-      resourceId: assJob.resourceId,
-      userId: assJob.userId,
+      resourceId: assJob.params.resourceId,
+      userId: assJob.metadata.userId,
       version: 1
     };
-    const isComplete = assJob.progress.percentage === 100 && assJob.result;
+    const isComplete = assJob.progress.percentage === 100;
     if (this.isFirstProgress) {
       this.isFirstProgress = false;
       await this.eventStore.appendEvent({
         type: "job.started",
         ...baseEvent,
         payload: {
-          jobId: assJob.id,
-          jobType: assJob.type
+          jobId: assJob.metadata.id,
+          jobType: assJob.metadata.type
         }
       });
     } else if (isComplete) {
@@ -1130,9 +1161,9 @@ var AssessmentDetectionWorker = class extends JobWorker3 {
         type: "job.completed",
         ...baseEvent,
         payload: {
-          jobId: assJob.id,
-          jobType: assJob.type,
-          result: assJob.result
+          jobId: assJob.metadata.id,
+          jobType: assJob.metadata.type
+          // Note: result would come from job.result, but that's handled by base class
         }
       });
     } else {
@@ -1140,8 +1171,8 @@ var AssessmentDetectionWorker = class extends JobWorker3 {
         type: "job.progress",
         ...baseEvent,
         payload: {
-          jobId: assJob.id,
-          jobType: assJob.type,
+          jobId: assJob.metadata.id,
+          jobType: assJob.metadata.type,
           progress: assJob.progress
         }
       });
@@ -1149,72 +1180,80 @@ var AssessmentDetectionWorker = class extends JobWorker3 {
   }
   async handleJobFailure(job, error) {
     await super.handleJobFailure(job, error);
-    if (job.status === "failed" && job.type === "assessment-detection") {
+    if (job.status === "failed" && job.metadata.type === "assessment-detection") {
       const aJob = job;
       await this.eventStore.appendEvent({
         type: "job.failed",
-        resourceId: aJob.resourceId,
-        userId: aJob.userId,
+        resourceId: aJob.params.resourceId,
+        userId: aJob.metadata.userId,
         version: 1,
         payload: {
-          jobId: aJob.id,
-          jobType: aJob.type,
+          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.resourceId} (job: ${job.id})`);
-    const resource = await ResourceContext.getResourceMetadata(job.resourceId, this.config);
+    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.resourceId} not found`);
+      throw new Error(`Resource ${job.params.resourceId} not found`);
     }
-    job.progress = {
-      stage: "analyzing",
-      percentage: 10,
-      message: "Loading resource..."
+    let updatedJob = {
+      ...job,
+      progress: {
+        stage: "analyzing",
+        percentage: 10,
+        message: "Loading resource..."
+      }
     };
-    await this.updateJobProgress(job);
-    job.progress = {
-      stage: "analyzing",
-      percentage: 30,
-      message: "Analyzing text..."
+    await this.updateJobProgress(updatedJob);
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "analyzing",
+        percentage: 30,
+        message: "Analyzing text..."
+      }
     };
-    await this.updateJobProgress(job);
+    await this.updateJobProgress(updatedJob);
     const assessments = await AnnotationDetection.detectAssessments(
-      job.resourceId,
+      job.params.resourceId,
       this.config,
-      job.instructions,
-      job.tone,
-      job.density
+      job.params.instructions,
+      job.params.tone,
+      job.params.density
     );
     console.log(`[AssessmentDetectionWorker] Found ${assessments.length} assessments to create`);
-    job.progress = {
-      stage: "creating",
-      percentage: 60,
-      message: `Creating ${assessments.length} annotations...`
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 60,
+        message: `Creating ${assessments.length} annotations...`
+      }
     };
-    await this.updateJobProgress(job);
+    await this.updateJobProgress(updatedJob);
     let created = 0;
     for (const assessment of assessments) {
       try {
-        await this.createAssessmentAnnotation(job.resourceId, job.userId, assessment);
+        await this.createAssessmentAnnotation(job.params.resourceId, job.metadata.userId, assessment);
         created++;
       } catch (error) {
         console.error(`[AssessmentDetectionWorker] Failed to create assessment:`, error);
       }
     }
-    job.result = {
-      assessmentsFound: assessments.length,
-      assessmentsCreated: created
-    };
-    job.progress = {
-      stage: "creating",
-      percentage: 100,
-      message: `Complete! Created ${created} assessments`
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 100,
+        message: `Complete! Created ${created} assessments`
+      }
     };
-    await this.updateJobProgress(job);
+    await this.updateJobProgress(updatedJob);
     console.log(`[AssessmentDetectionWorker] \u2705 Created ${created}/${assessments.length} assessments`);
   }
   async createAssessmentAnnotation(resourceId2, creatorUserId, assessment) {
@@ -1279,11 +1318,14 @@ var TagDetectionWorker = class extends JobWorker4 {
     return "TagDetectionWorker";
   }
   canProcessJob(job) {
-    return job.type === "tag-detection";
+    return job.metadata.type === "tag-detection";
   }
   async executeJob(job) {
-    if (job.type !== "tag-detection") {
-      throw new Error(`Invalid job type: ${job.type}`);
+    if (job.metadata.type !== "tag-detection") {
+      throw new Error(`Invalid job type: ${job.metadata.type}`);
+    }
+    if (job.status !== "running") {
+      throw new Error(`Job must be in running state to execute, got: ${job.status}`);
     }
     this.isFirstProgress = true;
     await this.processTagDetectionJob(job);
@@ -1293,23 +1335,25 @@ var TagDetectionWorker = class extends JobWorker4 {
    */
   async updateJobProgress(job) {
     await super.updateJobProgress(job);
-    if (job.type !== "tag-detection") return;
+    if (job.metadata.type !== "tag-detection") return;
+    if (job.status !== "running") {
+      return;
+    }
     const tdJob = job;
-    if (!tdJob.progress) return;
     const baseEvent = {
-      resourceId: tdJob.resourceId,
-      userId: tdJob.userId,
+      resourceId: tdJob.params.resourceId,
+      userId: tdJob.metadata.userId,
       version: 1
     };
-    const isComplete = tdJob.progress.percentage === 100 && tdJob.result;
+    const isComplete = tdJob.progress.percentage === 100;
     if (this.isFirstProgress) {
       this.isFirstProgress = false;
       await this.eventStore.appendEvent({
         type: "job.started",
         ...baseEvent,
         payload: {
-          jobId: tdJob.id,
-          jobType: tdJob.type
+          jobId: tdJob.metadata.id,
+          jobType: tdJob.metadata.type
         }
       });
     } else if (isComplete) {
@@ -1317,9 +1361,9 @@ var TagDetectionWorker = class extends JobWorker4 {
         type: "job.completed",
         ...baseEvent,
         payload: {
-          jobId: tdJob.id,
-          jobType: tdJob.type,
-          result: tdJob.result
+          jobId: tdJob.metadata.id,
+          jobType: tdJob.metadata.type
+          // Note: result would come from job.result, but that's handled by base class
         }
       });
     } else {
@@ -1327,8 +1371,8 @@ var TagDetectionWorker = class extends JobWorker4 {
         type: "job.progress",
         ...baseEvent,
         payload: {
-          jobId: tdJob.id,
-          jobType: tdJob.type,
+          jobId: tdJob.metadata.id,
+          jobType: tdJob.metadata.type,
           progress: tdJob.progress
         }
       });
@@ -1336,98 +1380,105 @@ var TagDetectionWorker = class extends JobWorker4 {
   }
   async handleJobFailure(job, error) {
     await super.handleJobFailure(job, error);
-    if (job.status === "failed" && job.type === "tag-detection") {
+    if (job.status === "failed" && job.metadata.type === "tag-detection") {
       const tdJob = job;
       await this.eventStore.appendEvent({
         type: "job.failed",
-        resourceId: tdJob.resourceId,
-        userId: tdJob.userId,
+        resourceId: tdJob.params.resourceId,
+        userId: tdJob.metadata.userId,
         version: 1,
         payload: {
-          jobId: tdJob.id,
-          jobType: tdJob.type,
+          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.resourceId} (job: ${job.id})`);
-    const schema = getTagSchema2(job.schemaId);
+    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.schemaId}`);
+      throw new Error(`Invalid tag schema: ${job.params.schemaId}`);
     }
-    for (const category of job.categories) {
+    for (const category of job.params.categories) {
       if (!schema.tags.some((t) => t.name === category)) {
-        throw new Error(`Invalid category "${category}" for schema ${job.schemaId}`);
+        throw new Error(`Invalid category "${category}" for schema ${job.params.schemaId}`);
       }
     }
-    const resource = await ResourceContext.getResourceMetadata(job.resourceId, this.config);
+    const resource = await ResourceContext.getResourceMetadata(job.params.resourceId, this.config);
     if (!resource) {
-      throw new Error(`Resource ${job.resourceId} not found`);
-    }
-    job.progress = {
-      stage: "analyzing",
-      percentage: 10,
-      processedCategories: 0,
-      totalCategories: job.categories.length,
-      message: "Loading resource..."
+      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(job);
+    await this.updateJobProgress(updatedJob);
     const allTags = [];
     const byCategory = {};
-    for (let i = 0; i < job.categories.length; i++) {
-      const category = job.categories[i];
-      job.progress = {
-        stage: "analyzing",
-        percentage: 10 + Math.floor(i / job.categories.length * 50),
-        currentCategory: category,
-        processedCategories: i + 1,
-        totalCategories: job.categories.length,
-        message: `Analyzing ${category}...`
+    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(job);
+      await this.updateJobProgress(updatedJob);
       const tags = await AnnotationDetection.detectTags(
-        job.resourceId,
+        job.params.resourceId,
         this.config,
-        job.schemaId,
+        job.params.schemaId,
         category
       );
       console.log(`[TagDetectionWorker] Found ${tags.length} tags for category "${category}"`);
       allTags.push(...tags);
       byCategory[category] = tags.length;
     }
-    job.progress = {
-      stage: "creating",
-      percentage: 60,
-      processedCategories: job.categories.length,
-      totalCategories: job.categories.length,
-      message: `Creating ${allTags.length} tag annotations...`
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 60,
+        processedCategories: job.params.categories.length,
+        totalCategories: job.params.categories.length,
+        message: `Creating ${allTags.length} tag annotations...`
+      }
     };
-    await this.updateJobProgress(job);
+    await this.updateJobProgress(updatedJob);
     let created = 0;
     for (const tag of allTags) {
       try {
-        await this.createTagAnnotation(job.resourceId, job.userId, job.schemaId, tag);
+        await this.createTagAnnotation(job.params.resourceId, job.metadata.userId, job.params.schemaId, tag);
         created++;
       } catch (error) {
         console.error(`[TagDetectionWorker] Failed to create tag:`, error);
       }
     }
-    job.result = {
-      tagsFound: allTags.length,
-      tagsCreated: created,
-      byCategory
-    };
-    job.progress = {
-      stage: "creating",
-      percentage: 100,
-      processedCategories: job.categories.length,
-      totalCategories: job.categories.length,
-      message: `Complete! Created ${created} tags`
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 100,
+        processedCategories: job.params.categories.length,
+        totalCategories: job.params.categories.length,
+        message: `Complete! Created ${created} tags`
+      }
     };
-    await this.updateJobProgress(job);
-    console.log(`[TagDetectionWorker] \u2705 Created ${created}/${allTags.length} tags across ${job.categories.length} categories`);
+    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;
@@ -1508,11 +1559,14 @@ var ReferenceDetectionWorker = class extends JobWorker5 {
     return "ReferenceDetectionWorker";
   }
   canProcessJob(job) {
-    return job.type === "detection";
+    return job.metadata.type === "detection";
   }
   async executeJob(job) {
-    if (job.type !== "detection") {
-      throw new Error(`Invalid job type: ${job.type}`);
+    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);
   }
@@ -1566,27 +1620,30 @@ var ReferenceDetectionWorker = class extends JobWorker5 {
     return detectedAnnotations;
   }
   async processDetectionJob(job) {
-    console.log(`[ReferenceDetectionWorker] Processing detection for resource ${job.resourceId} (job: ${job.id})`);
-    console.log(`[ReferenceDetectionWorker] \u{1F50D} Entity types: ${job.entityTypes.join(", ")}`);
-    const resource = await ResourceContext.getResourceMetadata(job.resourceId, this.config);
+    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.resourceId} not found`);
+      throw new Error(`Resource ${job.params.resourceId} not found`);
     }
     let totalFound = 0;
     let totalEmitted = 0;
     let totalErrors = 0;
-    job.progress = {
-      totalEntityTypes: job.entityTypes.length,
-      processedEntityTypes: 0,
-      entitiesFound: 0,
-      entitiesEmitted: 0
+    let updatedJob = {
+      ...job,
+      progress: {
+        totalEntityTypes: job.params.entityTypes.length,
+        processedEntityTypes: 0,
+        entitiesFound: 0,
+        entitiesEmitted: 0
+      }
     };
-    await this.updateJobProgress(job);
-    for (let i = 0; i < job.entityTypes.length; i++) {
-      const entityType = job.entityTypes[i];
+    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.entityTypes.length}] Detecting ${entityType}...`);
-      const detectedAnnotations = await this.detectReferences(resource, [entityType], job.includeDescriptiveReferences);
+      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++) {
@@ -1604,16 +1661,13 @@ var ReferenceDetectionWorker = class extends JobWorker5 {
           referenceId = generateAnnotationId5(backendUrl);
         } catch (error) {
           console.error(`[ReferenceDetectionWorker] Failed to generate annotation ID:`, error);
-          job.status = "failed";
-          job.error = "Configuration error: Backend publicURL not set";
-          await this.updateJobProgress(job);
-          return;
+          throw new Error("Configuration error: Backend publicURL not set");
         }
         try {
           await this.eventStore.appendEvent({
             type: "annotation.added",
-            resourceId: job.resourceId,
-            userId: job.userId,
+            resourceId: job.params.resourceId,
+            userId: job.metadata.userId,
             version: 1,
             payload: {
               annotation: {
@@ -1622,7 +1676,7 @@ var ReferenceDetectionWorker = class extends JobWorker5 {
                 id: referenceId,
                 motivation: "linking",
                 target: {
-                  source: resourceIdToURI6(job.resourceId, this.config.services.backend.publicURL),
+                  source: resourceIdToURI6(job.params.resourceId, this.config.services.backend.publicURL),
                   // Convert to full URI
                   selector: [
                     {
@@ -1657,34 +1711,32 @@ var ReferenceDetectionWorker = class extends JobWorker5 {
         }
       }
       console.log(`[ReferenceDetectionWorker] \u2705 Completed ${entityType}: ${detectedAnnotations.length} found, ${detectedAnnotations.length - (totalErrors - (totalFound - totalEmitted))} emitted`);
-      job.progress = {
-        totalEntityTypes: job.entityTypes.length,
-        processedEntityTypes: i + 1,
-        currentEntityType: entityType,
-        entitiesFound: totalFound,
-        entitiesEmitted: totalEmitted
+      updatedJob = {
+        ...updatedJob,
+        progress: {
+          totalEntityTypes: job.params.entityTypes.length,
+          processedEntityTypes: i + 1,
+          currentEntityType: entityType,
+          entitiesFound: totalFound,
+          entitiesEmitted: totalEmitted
+        }
       };
-      await this.updateJobProgress(job);
+      await this.updateJobProgress(updatedJob);
     }
-    job.result = {
-      totalFound,
-      totalEmitted,
-      errors: totalErrors
-    };
     console.log(`[ReferenceDetectionWorker] \u2705 Detection complete: ${totalFound} entities found, ${totalEmitted} events emitted, ${totalErrors} errors`);
   }
   async handleJobFailure(job, error) {
     await super.handleJobFailure(job, error);
-    if (job.status === "failed" && job.type === "detection") {
+    if (job.status === "failed" && job.metadata.type === "detection") {
       const detJob = job;
       await this.eventStore.appendEvent({
         type: "job.failed",
-        resourceId: detJob.resourceId,
-        userId: detJob.userId,
+        resourceId: detJob.params.resourceId,
+        userId: detJob.metadata.userId,
         version: 1,
         payload: {
-          jobId: detJob.id,
-          jobType: detJob.type,
+          jobId: detJob.metadata.id,
+          jobType: detJob.metadata.type,
           error: "Entity detection failed. Please try again later."
         }
       });
@@ -1696,18 +1748,18 @@ var ReferenceDetectionWorker = class extends JobWorker5 {
    */
   async updateJobProgress(job) {
     await super.updateJobProgress(job);
-    if (job.type !== "detection") {
+    if (job.metadata.type !== "detection") {
+      return;
+    }
+    if (job.status !== "running") {
       return;
     }
     const detJob = job;
     const baseEvent = {
-      resourceId: detJob.resourceId,
-      userId: detJob.userId,
+      resourceId: detJob.params.resourceId,
+      userId: detJob.metadata.userId,
       version: 1
     };
-    if (!detJob.progress) {
-      return;
-    }
     const isFirstUpdate = detJob.progress.processedEntityTypes === 0;
     const isFinalUpdate = detJob.progress.processedEntityTypes === detJob.progress.totalEntityTypes && detJob.progress.totalEntityTypes > 0;
     if (isFirstUpdate) {
@@ -1715,9 +1767,9 @@ var ReferenceDetectionWorker = class extends JobWorker5 {
         type: "job.started",
         ...baseEvent,
         payload: {
-          jobId: detJob.id,
-          jobType: detJob.type,
-          totalSteps: detJob.entityTypes.length
+          jobId: detJob.metadata.id,
+          jobType: detJob.metadata.type,
+          totalSteps: detJob.params.entityTypes.length
         }
       });
     } else if (isFinalUpdate) {
@@ -1725,8 +1777,8 @@ var ReferenceDetectionWorker = class extends JobWorker5 {
         type: "job.completed",
         ...baseEvent,
         payload: {
-          jobId: detJob.id,
-          jobType: detJob.type,
+          jobId: detJob.metadata.id,
+          jobType: detJob.metadata.type,
           foundCount: detJob.progress.entitiesFound
         }
       });
@@ -1736,8 +1788,8 @@ var ReferenceDetectionWorker = class extends JobWorker5 {
         type: "job.progress",
         ...baseEvent,
         payload: {
-          jobId: detJob.id,
-          jobType: detJob.type,
+          jobId: detJob.metadata.id,
+          jobType: detJob.metadata.type,
           percentage,
           currentStep: detJob.progress.currentEntityType,
           processedSteps: detJob.progress.processedEntityTypes,
@@ -1776,88 +1828,103 @@ var GenerationWorker = class extends JobWorker6 {
     return "GenerationWorker";
   }
   canProcessJob(job) {
-    return job.type === "generation";
+    return job.metadata.type === "generation";
   }
   async executeJob(job) {
-    if (job.type !== "generation") {
-      throw new Error(`Invalid job type: ${job.type}`);
+    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.referenceId} (job: ${job.id})`);
+    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);
-    job.progress = {
-      stage: "fetching",
-      percentage: 20,
-      message: "Fetching source resource..."
+    let updatedJob = {
+      ...job,
+      progress: {
+        stage: "fetching",
+        percentage: 20,
+        message: "Fetching source resource..."
+      }
     };
-    console.log(`[GenerationWorker] \u{1F4E5} ${job.progress.message}`);
-    await this.updateJobProgress(job);
+    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.sourceResourceId);
+    const view = await viewStorage.get(job.params.sourceResourceId);
     if (!view) {
-      throw new Error(`Resource ${job.sourceResourceId} not found`);
+      throw new Error(`Resource ${job.params.sourceResourceId} not found`);
     }
     const projection = view.annotations;
-    const expectedAnnotationUri = `${this.config.services.backend.publicURL}/annotations/${job.referenceId}`;
+    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.referenceId} not found in resource ${job.sourceResourceId}`);
+      throw new Error(`Annotation ${job.params.referenceId} not found in resource ${job.params.sourceResourceId}`);
     }
-    const sourceResource = await ResourceContext.getResourceMetadata(job.sourceResourceId, this.config);
+    const sourceResource = await ResourceContext.getResourceMetadata(job.params.sourceResourceId, this.config);
     if (!sourceResource) {
-      throw new Error(`Source resource ${job.sourceResourceId} not found`);
+      throw new Error(`Source resource ${job.params.sourceResourceId} not found`);
     }
     const targetSelector = getTargetSelector2(annotation.target);
-    const resourceName = job.title || (targetSelector ? getExactText(targetSelector) : "") || "New Resource";
+    const resourceName = job.params.title || (targetSelector ? getExactText(targetSelector) : "") || "New Resource";
     console.log(`[GenerationWorker] Generating resource: "${resourceName}"`);
-    if (!job.context) {
+    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.context.sourceContext?.before?.length || 0} chars before, ${job.context.sourceContext?.selected?.length || 0} chars selected, ${job.context.sourceContext?.after?.length || 0} chars after`);
-    job.progress = {
-      stage: "generating",
-      percentage: 40,
-      message: "Creating content with AI..."
+    console.log(`[GenerationWorker] 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} ${job.progress.message}`);
-    await this.updateJobProgress(job);
-    const prompt = job.prompt || `Create a comprehensive resource about "${resourceName}"`;
+    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.entityTypes || annotationEntityTypes,
+      job.params.entityTypes || annotationEntityTypes,
       this.config,
       prompt,
-      job.language,
-      job.context,
+      job.params.language,
+      job.params.context,
       // NEW - context from job (passed from modal)
-      job.temperature,
+      job.params.temperature,
       // NEW - from job
-      job.maxTokens
+      job.params.maxTokens
       // NEW - from job
     );
     console.log(`[GenerationWorker] \u2705 Generated ${generatedContent.content.length} bytes of content`);
-    job.progress = {
-      stage: "generating",
-      percentage: 70,
-      message: "Content ready, creating resource..."
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "generating",
+        percentage: 70,
+        message: "Content ready, creating resource..."
+      }
     };
-    await this.updateJobProgress(job);
+    await this.updateJobProgress(updatedJob);
     const rId = resourceId(generateUuid());
-    job.progress = {
-      stage: "creating",
-      percentage: 85,
-      message: "Saving resource..."
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "creating",
+        percentage: 85,
+        message: "Saving resource..."
+      }
     };
-    console.log(`[GenerationWorker] \u{1F4BE} ${job.progress.message}`);
-    await this.updateJobProgress(job);
+    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"
@@ -1866,29 +1933,34 @@ var GenerationWorker = class extends JobWorker6 {
     await this.eventStore.appendEvent({
       type: "resource.created",
       resourceId: rId,
-      userId: job.userId,
+      userId: job.metadata.userId,
       version: 1,
       payload: {
         name: resourceName,
         format: "text/markdown",
         contentChecksum: storedRep.checksum,
         creationMethod: CREATION_METHODS.GENERATED,
-        entityTypes: job.entityTypes || annotationEntityTypes,
-        language: job.language,
+        entityTypes: job.params.entityTypes || annotationEntityTypes,
+        language: job.params.language,
         isDraft: true,
-        generatedFrom: job.referenceId,
+        generatedFrom: job.params.referenceId,
         generationPrompt: void 0
         // Could be added if we track the prompt
       }
     });
     console.log(`[GenerationWorker] Emitted resource.created event for ${rId}`);
-    job.progress = {
-      stage: "linking",
-      percentage: 95,
-      message: "Linking reference..."
+    updatedJob = {
+      ...updatedJob,
+      progress: {
+        stage: "linking",
+        percentage: 95,
+        message: "Linking reference...",
+        resultResourceId: rId
+        // Store for job.completed event
+      }
     };
-    console.log(`[GenerationWorker] \u{1F517} ${job.progress.message}`);
-    await this.updateJobProgress(job);
+    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",
@@ -1898,28 +1970,29 @@ var GenerationWorker = class extends JobWorker6 {
         purpose: "linking"
       }
     }];
-    const annotationIdSegment = job.referenceId.split("/").pop();
+    const annotationIdSegment = job.params.referenceId.split("/").pop();
     await this.eventStore.appendEvent({
       type: "annotation.body.updated",
-      resourceId: job.sourceResourceId,
-      userId: job.userId,
+      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.referenceId} \u2192 ${rId}`);
-    job.result = {
-      resourceId: rId,
-      resourceName
-    };
-    job.progress = {
-      stage: "linking",
-      percentage: 100,
-      message: "Complete!"
+    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(job);
+    await this.updateJobProgress(updatedJob);
     console.log(`[GenerationWorker] \u2705 Generation complete: created resource ${rId}`);
   }
   /**
@@ -1928,44 +2001,47 @@ var GenerationWorker = class extends JobWorker6 {
    */
   async updateJobProgress(job) {
     await super.updateJobProgress(job);
-    if (job.type !== "generation") {
+    if (job.metadata.type !== "generation") {
+      return;
+    }
+    if (job.status !== "running") {
       return;
     }
     const genJob = job;
     const baseEvent = {
-      resourceId: genJob.sourceResourceId,
-      userId: genJob.userId,
+      resourceId: genJob.params.sourceResourceId,
+      userId: genJob.metadata.userId,
       version: 1
     };
-    if (genJob.progress?.stage === "fetching" && genJob.progress?.percentage === 20) {
+    if (genJob.progress.stage === "fetching" && genJob.progress.percentage === 20) {
       await this.eventStore.appendEvent({
         type: "job.started",
         ...baseEvent,
         payload: {
-          jobId: genJob.id,
-          jobType: genJob.type,
+          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) {
+    } else if (genJob.progress.stage === "linking" && genJob.progress.percentage === 100) {
       await this.eventStore.appendEvent({
         type: "job.completed",
         ...baseEvent,
         payload: {
-          jobId: genJob.id,
-          jobType: genJob.type,
-          resultResourceId: genJob.result?.resourceId,
-          annotationUri: annotationUri(`${this.config.services.backend.publicURL}/annotations/${genJob.referenceId}`)
+          jobId: genJob.metadata.id,
+          jobType: genJob.metadata.type,
+          resultResourceId: genJob.progress.resultResourceId,
+          annotationUri: annotationUri(`${this.config.services.backend.publicURL}/annotations/${genJob.params.referenceId}`)
         }
       });
-    } else if (genJob.progress) {
+    } else {
       await this.eventStore.appendEvent({
         type: "job.progress",
         ...baseEvent,
         payload: {
-          jobId: genJob.id,
-          jobType: genJob.type,
+          jobId: genJob.metadata.id,
+          jobType: genJob.metadata.type,
           currentStep: genJob.progress.stage,
           percentage: genJob.progress.percentage,
           message: genJob.progress.message