@semiont/jobs 0.5.32 → 0.5.34

package/dist/index.js

@@ -557,12 +557,16 @@ var YieldCollapseError = class extends DeterministicJobError {
   /** What the flagged extraction DID find — every span write-time-verified,
    * so discarding it at the floor would add loss on top of the under-report.
    * Carried on the error because the flag site cannot know whether descent
-   * remains possible; the floor is the subdivider's knowledge. */
-  constructor(message, salvage = []) {
+   * remains possible; the floor is the subdivider's knowledge. The verdict
+   * rides beside it so an acceptance can report evidence, not a message
+   * string. */
+  constructor(message, salvage, verdict) {
     super(message);
     this.salvage = salvage;
+    this.verdict = verdict;
   }
   salvage;
+  verdict;
   name = "YieldCollapseError";
 };
 function deriveDetectionBudget(limits, scaffoldTokens, typesPerCall) {
@@ -616,7 +620,7 @@ function outcomeOf(error) {
   if (error instanceof InferenceTimeoutError) return "timeout";
   return "error";
 }
-async function callChunkSubdividing(label, chunk, chunking, call, logger) {
+async function callChunkSubdividing(label, chunk, chunking, call, logger, onUnderReport, onCounted) {
   async function recorded(piece, depth, reroll) {
     const start = performance.now();
     try {
@@ -631,6 +635,7 @@ async function callChunkSubdividing(label, chunk, chunking, call, logger) {
         outcome: "success",
         ...result.usage ? { inputTokens: result.usage.inputTokens, outputTokens: result.usage.outputTokens } : {}
       });
+      if (result.counted !== void 0) onCounted?.(result.counted);
       return result;
     } catch (error) {
       recordDetectionCall({
@@ -661,6 +666,8 @@ async function callChunkSubdividing(label, chunk, chunking, call, logger) {
             salvaged: error.salvage.length,
             error: error.message
           });
+          onUnderReport?.(error.verdict);
+          onCounted?.(error.verdict.counted);
           return error.salvage;
         }
         if (!truncation(error)) throw error;
@@ -1184,7 +1191,7 @@ function logAnchorMethod(motivation, exact, anchorMethod) {
 }
 
 // src/workers/annotation-detection.ts
-async function detectInChunks(client, content, buildPrompt, motivation, elementSchema, parse, onActivity) {
+async function detectInChunks(client, content, buildPrompt, motivation, elementSchema, parse, onActivity, onChunkResults) {
   const limits = await client.limits();
   const scaffoldTokens = estimateTokens(buildPrompt(""));
   const { chunking, outputBudget } = deriveDetectionBudget(limits, scaffoldTokens, 1);
@@ -1204,7 +1211,9 @@ async function detectInChunks(client, content, buildPrompt, motivation, elementS
       assertNotTruncated(response, `${motivation} detection`, i + 1, chunks.length, outputBudget);
       return { items: response.items, ...response.usage ? { usage: response.usage } : {} };
     });
-    collected.push(...parse(items));
+    const fromChunk = parse(items);
+    collected.push(...fromChunk);
+    await onChunkResults?.(fromChunk);
     if (i < chunks.length - 1) {
       onActivity?.(i + 1, chunks.length);
     }
@@ -1220,7 +1229,7 @@ var AnnotationDetection = class {
    * (source-resource locale). See `types.ts` "Locale conventions" for the
    * full discussion.
    */
-  static async detectComments(content, client, instructions, tone, density, language, sourceLanguage, onActivity) {
+  static async detectComments(content, client, instructions, tone, density, language, sourceLanguage, onActivity, onChunkResults) {
     return detectInChunks(
       client,
       content,
@@ -1228,7 +1237,8 @@ var AnnotationDetection = class {
       "comment",
       COMMENT_ELEMENT_SCHEMA,
       (items) => MotivationParsers.parseComments(items, content),
-      onActivity
+      onActivity,
+      onChunkResults
     );
   }
   /**
@@ -1238,7 +1248,7 @@ var AnnotationDetection = class {
    * applies, used in the prompt so the LLM analyzes non-English source
    * correctly.
    */
-  static async detectHighlights(content, client, instructions, density, sourceLanguage, onActivity) {
+  static async detectHighlights(content, client, instructions, density, sourceLanguage, onActivity, onChunkResults) {
     return detectInChunks(
       client,
       content,
@@ -1246,7 +1256,8 @@ var AnnotationDetection = class {
       "highlight",
       HIGHLIGHT_ELEMENT_SCHEMA,
       (items) => MotivationParsers.parseHighlights(items, content),
-      onActivity
+      onActivity,
+      onChunkResults
     );
   }
   /**
@@ -1256,7 +1267,7 @@ var AnnotationDetection = class {
    * (annotation body locale). `sourceLanguage` is the locale of the content
    * being analyzed (source-resource locale).
    */
-  static async detectAssessments(content, client, instructions, tone, density, language, sourceLanguage, onActivity) {
+  static async detectAssessments(content, client, instructions, tone, density, language, sourceLanguage, onActivity, onChunkResults) {
     return detectInChunks(
       client,
       content,
@@ -1264,7 +1275,8 @@ var AnnotationDetection = class {
       "assessment",
       ASSESSMENT_ELEMENT_SCHEMA,
       (items) => MotivationParsers.parseAssessments(items, content),
-      onActivity
+      onActivity,
+      onChunkResults
     );
   }
   /**
@@ -1279,7 +1291,7 @@ var AnnotationDetection = class {
    * identifiers, not LLM-generated text — so it's consumed at the body-stamp
    * site, not here.
    */
-  static async detectTags(content, client, schema, category, sourceLanguage, onActivity) {
+  static async detectTags(content, client, schema, category, sourceLanguage, onActivity, onChunkResults) {
     const categoryInfo = schema.tags.find((t) => t.name === category);
     if (!categoryInfo) {
       throw new Error(`Invalid category "${category}" for schema ${schema.id}`);
@@ -1300,7 +1312,8 @@ var AnnotationDetection = class {
       "tag",
       TAG_ELEMENT_SCHEMA,
       (items) => MotivationParsers.parseTags(items),
-      onActivity
+      onActivity,
+      onChunkResults ? async (raw) => onChunkResults(MotivationParsers.validateTagOffsets(raw, content, category)) : void 0
     );
     return MotivationParsers.validateTagOffsets(parsedTags, content, category);
   }
@@ -1337,20 +1350,22 @@ ${piece}
       pieceChars: piece.length,
       error: err instanceof Error ? err.message : String(err)
     });
-    return;
+    return void 0;
   }
   if (counted === void 0) {
     logger.warn("Count-verifier answer carried no number \u2014 yield check skipped for this chunk", { pieceChars: piece.length });
-    return;
+    return void 0;
   }
   if (items.length * YIELD_COLLAPSE_BAND < counted) {
     throw new YieldCollapseError(
       `Extraction found ${items.length} entities where a count call reports ~${counted} mentions (band \xD7${YIELD_COLLAPSE_BAND}) on a ${piece.length}-char chunk \u2014 silent yield collapse (F7): deterministic \u2014 a same-size retry returns the identical under-report.`,
-      [...items]
+      [...items],
+      { found: items.length, counted, pieceChars: piece.length }
     );
   }
+  return counted;
 }
-async function extractEntities(exact, entityTypes, client, includeDescriptiveReferences, logger, sourceLanguage, onActivity) {
+async function extractEntities(exact, entityTypes, client, includeDescriptiveReferences, logger, sourceLanguage, onActivity, onUnderReport, onCounted, onChunkResults) {
   const entityTypesDescription = entityTypes.map((et) => {
     if (typeof et === "string") {
       return et;
@@ -1431,14 +1446,17 @@ Example output:
         items: response.items.length
       });
       assertNotTruncated(response, "Entity extraction", i + 1, chunks.length, outputBudget);
-      if (verifyYield) {
-        await assertYieldNotCollapsed(client, piece, response.items, entityTypesDescription, logger);
-      }
-      return { items: response.items, ...response.usage ? { usage: response.usage } : {} };
-    }, logger);
+      const counted = verifyYield ? await assertYieldNotCollapsed(client, piece, response.items, entityTypesDescription, logger) : void 0;
+      return {
+        items: response.items,
+        ...response.usage ? { usage: response.usage } : {},
+        ...counted !== void 0 ? { counted } : {}
+      };
+    }, logger, onUnderReport, onCounted);
+    const fromChunk = [];
     for (const e of items) {
       if (isObject(e) && isString(e.exact) && isString(e.entityType)) {
-        collected.push({
+        fromChunk.push({
           exact: e.exact,
           entityType: e.entityType,
           ...isString(e.prefix) ? { prefix: e.prefix } : {},
@@ -1448,6 +1466,8 @@ Example output:
         logger.debug("Dropped malformed LLM entity", { entity: e });
       }
     }
+    collected.push(...fromChunk);
+    await onChunkResults?.(fromChunk);
     if (i < chunks.length - 1) {
       onActivity?.(i + 1, chunks.length);
     }
@@ -1803,38 +1823,45 @@ function annotationDedupeKey(ann) {
   }
   return [ann.motivation, anchor, JSON.stringify(ann.body ?? null)].join("|");
 }
-function dedupeAnnotations(annotations) {
+function makeSpanDeduper() {
   const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const ann of annotations) {
-    const key = annotationDedupeKey(ann);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push(ann);
-  }
-  return out;
+  return (annotations) => {
+    const out = [];
+    for (const ann of annotations) {
+      const key = annotationDedupeKey(ann);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(ann);
+    }
+    return out;
+  };
 }
-async function processHighlightJob(content, inferenceClient, params, buildAnnotation, onProgress) {
+async function processHighlightJob(content, inferenceClient, params, buildAnnotation, onProgress, onChunkComplete) {
   const echo = detectionEcho(params);
   onProgress(10, { code: "loading" }, echo);
   onProgress(30, { code: "analyzing" }, echo);
-  const highlights = await AnnotationDetection.detectHighlights(
+  const dedupe = makeSpanDeduper();
+  let found = 0;
+  let created = 0;
+  await AnnotationDetection.detectHighlights(
     content,
     inferenceClient,
     params.instructions,
     params.density,
     params.sourceLanguage,
     // Liveness (chunk boundaries + in-flight heartbeat): 30–60 band.
-    (completed, total) => onProgress(30 + Math.round(completed / total * 30), { code: "analyzing" }, echo)
+    (completed, total) => onProgress(30 + Math.round(completed / total * 30), { code: "analyzing" }, echo),
+    async (matches) => {
+      found += matches.length;
+      const fresh = dedupe(matches.map((h) => buildAnnotation("highlighting", h)));
+      created += fresh.length;
+      onProgress(60, { code: "creating-annotations", count: created }, echo);
+      await onChunkComplete(fresh);
+    }
   );
-  onProgress(60, { code: "creating-annotations", count: highlights.length }, echo);
-  const annotations = dedupeAnnotations(highlights.map(
-    (h) => buildAnnotation("highlighting", h)
-  ));
-  onProgress(100, { code: "complete-created", count: annotations.length, kind: "highlight" }, echo);
+  onProgress(100, { code: "complete-created", count: created, kind: "highlight" }, echo);
   return {
-    annotations,
-    result: { kind: "highlight-annotation", highlightsFound: highlights.length, highlightsCreated: annotations.length }
+    result: { kind: "highlight-annotation", highlightsFound: found, highlightsCreated: created }
   };
 }
 function detectionEcho(p) {
@@ -1844,11 +1871,15 @@ function detectionEcho(p) {
   if (p.density !== void 0) requestParams.push({ label: "density", value: String(p.density) });
   return requestParams.length > 0 ? { requestParams } : {};
 }
-async function processCommentJob(content, inferenceClient, params, buildAnnotation, onProgress) {
+async function processCommentJob(content, inferenceClient, params, buildAnnotation, onProgress, onChunkComplete) {
   const echo = detectionEcho(params);
   onProgress(10, { code: "loading" }, echo);
   onProgress(30, { code: "analyzing" }, echo);
-  const comments = await AnnotationDetection.detectComments(
+  const bodyLanguage = params.language ?? "en";
+  const dedupe = makeSpanDeduper();
+  let found = 0;
+  let created = 0;
+  await AnnotationDetection.detectComments(
     content,
     inferenceClient,
     params.instructions,
@@ -1857,31 +1888,38 @@ async function processCommentJob(content, inferenceClient, params, buildAnnotati
     params.language,
     params.sourceLanguage,
     // Liveness (chunk boundaries + in-flight heartbeat): 30–60 band.
-    (completed, total) => onProgress(30 + Math.round(completed / total * 30), { code: "analyzing" }, echo)
+    (completed, total) => onProgress(30 + Math.round(completed / total * 30), { code: "analyzing" }, echo),
+    async (comments) => {
+      found += comments.length;
+      const fresh = dedupe(comments.map(
+        (c) => (
+          // Match the pre-#651 CommentAnnotationWorker: include format and
+          // language on the body TextualBody. Optional in the schema, but
+          // consumers that do language-aware rendering rely on them.
+          buildAnnotation("commenting", c, [
+            { type: "TextualBody", value: c.comment, purpose: "commenting", format: "text/plain", language: bodyLanguage }
+          ])
+        )
+      ));
+      created += fresh.length;
+      onProgress(60, { code: "creating-annotations", count: created }, echo);
+      await onChunkComplete(fresh);
+    }
   );
-  onProgress(60, { code: "creating-annotations", count: comments.length }, echo);
-  const bodyLanguage = params.language ?? "en";
-  const annotations = dedupeAnnotations(comments.map(
-    (c) => (
-      // Match the pre-#651 CommentAnnotationWorker: include format and
-      // language on the body TextualBody. Optional in the schema, but
-      // consumers that do language-aware rendering rely on them.
-      buildAnnotation("commenting", c, [
-        { type: "TextualBody", value: c.comment, purpose: "commenting", format: "text/plain", language: bodyLanguage }
-      ])
-    )
-  ));
-  onProgress(100, { code: "complete-created", count: annotations.length, kind: "comment" }, echo);
+  onProgress(100, { code: "complete-created", count: created, kind: "comment" }, echo);
   return {
-    annotations,
-    result: { kind: "comment-annotation", commentsFound: comments.length, commentsCreated: annotations.length }
+    result: { kind: "comment-annotation", commentsFound: found, commentsCreated: created }
   };
 }
-async function processAssessmentJob(content, inferenceClient, params, buildAnnotation, onProgress) {
+async function processAssessmentJob(content, inferenceClient, params, buildAnnotation, onProgress, onChunkComplete) {
   const echo = detectionEcho(params);
   onProgress(10, { code: "loading" }, echo);
   onProgress(30, { code: "analyzing" }, echo);
-  const assessments = await AnnotationDetection.detectAssessments(
+  const bodyLanguage = params.language ?? "en";
+  const dedupe = makeSpanDeduper();
+  let found = 0;
+  let created = 0;
+  await AnnotationDetection.detectAssessments(
     content,
     inferenceClient,
     params.instructions,
@@ -1890,40 +1928,45 @@ async function processAssessmentJob(content, inferenceClient, params, buildAnnot
     params.language,
     params.sourceLanguage,
     // Liveness (chunk boundaries + in-flight heartbeat): 30–60 band.
-    (completed, total) => onProgress(30 + Math.round(completed / total * 30), { code: "analyzing" }, echo)
+    (completed, total) => onProgress(30 + Math.round(completed / total * 30), { code: "analyzing" }, echo),
+    async (assessments) => {
+      found += assessments.length;
+      const fresh = dedupe(assessments.map(
+        (a) => (
+          // Single-object body with purpose aligned to motivation, matching the
+          // pre-#651 AssessmentAnnotationWorker's shape and the majority of
+          // persisted assessments. Do not switch to an array or to
+          // purpose='describing' — that loses the "this is an assessment, not
+          // a description" signal and breaks existing readers that access
+          // `body.value` directly on the object.
+          buildAnnotation("assessing", a, {
+            type: "TextualBody",
+            value: a.assessment,
+            purpose: "assessing",
+            format: "text/plain",
+            language: bodyLanguage
+          })
+        )
+      ));
+      created += fresh.length;
+      onProgress(60, { code: "creating-annotations", count: created }, echo);
+      await onChunkComplete(fresh);
+    }
   );
-  onProgress(60, { code: "creating-annotations", count: assessments.length }, echo);
-  const bodyLanguage = params.language ?? "en";
-  const annotations = dedupeAnnotations(assessments.map(
-    (a) => (
-      // Single-object body with purpose aligned to motivation, matching the
-      // pre-#651 AssessmentAnnotationWorker's shape and the majority of
-      // persisted assessments. Do not switch to an array or to
-      // purpose='describing' — that loses the "this is an assessment, not
-      // a description" signal and breaks existing readers that access
-      // `body.value` directly on the object.
-      buildAnnotation("assessing", a, {
-        type: "TextualBody",
-        value: a.assessment,
-        purpose: "assessing",
-        format: "text/plain",
-        language: bodyLanguage
-      })
-    )
-  ));
-  onProgress(100, { code: "complete-created", count: annotations.length, kind: "assessment" }, echo);
+  onProgress(100, { code: "complete-created", count: created, kind: "assessment" }, echo);
   return {
-    annotations,
-    result: { kind: "assessment-annotation", assessmentsFound: assessments.length, assessmentsCreated: annotations.length }
+    result: { kind: "assessment-annotation", assessmentsFound: found, assessmentsCreated: created }
   };
 }
-async function processReferenceJob(content, inferenceClient, params, buildAnnotation, onProgress, logger, onUnitComplete, signal) {
+async function processReferenceJob(content, inferenceClient, params, buildAnnotation, onProgress, logger, onUnitComplete, signal, onChunkComplete) {
   const entityTypeNames = params.entityTypes.map(String);
   const requestParams = [{ label: "entity-types", value: entityTypeNames.join(", ") }];
   const completedItems = [];
   let totalFound = 0;
   let totalEmitted = 0;
   let errors = 0;
+  let totalUnderReportedPieces = 0;
+  let totalExpected = 0;
   onProgress(10, { code: "loading" }, { requestParams });
   const bodyLanguage = params.language ?? "en";
   let completed = 0;
@@ -1935,6 +1978,7 @@ async function processReferenceJob(content, inferenceClient, params, buildAnnota
       processed: completed,
       total,
       entitiesFound: totalFound,
+      ...totalExpected > 0 ? { entitiesExpected: totalExpected } : {},
       entitiesEmitted: totalEmitted,
       completedItems: [...completedItems],
       requestParams
@@ -1944,7 +1988,14 @@ async function processReferenceJob(content, inferenceClient, params, buildAnnota
     if (!entityTypeName) return;
     if (signal?.aborted) return;
     emitTypeProgress(entityTypeName);
-    const extractedEntities = await extractEntities(
+    const unresolvedBody = [
+      { type: "TextualBody", value: entityTypeName, purpose: "tagging", format: "text/plain", language: bodyLanguage }
+    ];
+    const dedupe = makeSpanDeduper();
+    let unitFound = 0;
+    let unitPersisted = 0;
+    let underReported;
+    await extractEntities(
       content,
       [entityTypeName],
       inferenceClient,
@@ -1956,54 +2007,80 @@ async function processReferenceJob(content, inferenceClient, params, buildAnnota
       // not silent. It repeats the current position rather than inventing an
       // advance — the stall watchdog, janitor and client timeout need a signal,
       // not a monotone.
-      () => emitTypeProgress(entityTypeName)
-    );
-    const unresolvedBody = [
-      { type: "TextualBody", value: entityTypeName, purpose: "tagging", format: "text/plain", language: bodyLanguage }
-    ];
-    const built = [];
-    for (const entity of extractedEntities) {
-      const reconciled = reconcileSelector(content, {
-        exact: entity.exact,
-        ...entity.prefix !== void 0 ? { prefix: entity.prefix } : {},
-        ...entity.suffix !== void 0 ? { suffix: entity.suffix } : {}
-      });
-      if (!reconciled) {
-        logger.error("Entity dropped \u2014 text not found in source", {
-          text: entity.exact,
-          entityType: entity.entityType
-        });
-        errors++;
-        continue;
+      () => emitTypeProgress(entityTypeName),
+      (verdict) => {
+        underReported = {
+          pieces: (underReported?.pieces ?? 0) + 1,
+          found: (underReported?.found ?? 0) + verdict.found,
+          counted: (underReported?.counted ?? 0) + verdict.counted
+        };
+      },
+      (counted) => {
+        totalExpected += counted;
+        emitTypeProgress(entityTypeName);
+      },
+      async (chunkEntities) => {
+        const built = [];
+        for (const entity of chunkEntities) {
+          const reconciled = reconcileSelector(content, {
+            exact: entity.exact,
+            ...entity.prefix !== void 0 ? { prefix: entity.prefix } : {},
+            ...entity.suffix !== void 0 ? { suffix: entity.suffix } : {}
+          });
+          if (!reconciled) {
+            logger.error("Entity dropped \u2014 text not found in source", {
+              text: entity.exact,
+              entityType: entity.entityType
+            });
+            errors++;
+            continue;
+          }
+          noteAnchor("reference", entity.exact, reconciled.anchorMethod, logger);
+          built.push(buildAnnotation("linking", toMatch(reconciled), unresolvedBody));
+        }
+        const fresh = dedupe(built);
+        await onChunkComplete?.(fresh);
+        unitFound += chunkEntities.length;
+        unitPersisted += fresh.length;
+        totalFound += chunkEntities.length;
+        totalEmitted += fresh.length;
+        emitTypeProgress(entityTypeName);
       }
-      noteAnchor("reference", entity.exact, reconciled.anchorMethod, logger);
-      const ann = buildAnnotation("linking", toMatch(reconciled), unresolvedBody);
-      built.push(ann);
-    }
-    const unitAnnotations = dedupeAnnotations(built);
-    await onUnitComplete(entityTypeName, unitAnnotations);
-    totalEmitted += unitAnnotations.length;
-    totalFound += extractedEntities.length;
+    );
+    await onUnitComplete(entityTypeName);
     completedItems.push({
       value: entityTypeName,
-      foundCount: extractedEntities.length,
-      persistedCount: unitAnnotations.length
+      foundCount: unitFound,
+      persistedCount: unitPersisted,
+      ...underReported ? { underReported } : {}
     });
+    if (underReported) totalUnderReportedPieces += underReported.pieces;
     completed++;
     emitTypeProgress(entityTypeName);
   });
   onProgress(100, { code: "complete-created", count: totalEmitted, kind: "reference" }, {
+    ...totalExpected > 0 ? { entitiesExpected: totalExpected } : {},
     completedItems: [...completedItems],
     requestParams
   });
   return {
-    result: { kind: "reference-annotation", totalFound, totalEmitted, errors }
+    result: {
+      kind: "reference-annotation",
+      totalFound,
+      totalEmitted,
+      errors,
+      ...totalUnderReportedPieces > 0 ? { underReportedPieces: totalUnderReportedPieces } : {}
+    }
   };
 }
-async function processTagJob(content, inferenceClient, params, buildAnnotation, onProgress) {
+async function processTagJob(content, inferenceClient, params, buildAnnotation, onProgress, onChunkComplete) {
   onProgress(10, { code: "loading" });
   onProgress(30, { code: "analyzing-tags" });
-  const allTags = [];
+  const bodyLanguage = params.language ?? "en";
+  const dedupe = makeSpanDeduper();
+  let found = 0;
+  let created = 0;
+  const byCategory = {};
   const completedItems = [];
   for (let c = 0; c < params.categories.length; c++) {
     const category = params.categories[c];
@@ -2018,7 +2095,8 @@ async function processTagJob(content, inferenceClient, params, buildAnnotation,
       { code: "analyzing-tags" },
       position()
     );
-    const categoryTags = await AnnotationDetection.detectTags(
+    let categoryFound = 0;
+    await AnnotationDetection.detectTags(
       content,
       inferenceClient,
       params.schema,
@@ -2030,31 +2108,32 @@ async function processTagJob(content, inferenceClient, params, buildAnnotation,
         30 + Math.round((c + completed / total) / params.categories.length * 30),
         { code: "analyzing-tags" },
         position()
-      )
+      ),
+      async (matches) => {
+        categoryFound += matches.length;
+        const fresh = dedupe(matches.map((t) => {
+          const cat = t.category ?? "unknown";
+          return buildAnnotation("tagging", t, [
+            { type: "TextualBody", value: cat, purpose: "tagging", format: "text/plain", language: bodyLanguage },
+            { type: "TextualBody", value: params.schema.id, purpose: "classifying", format: "text/plain" }
+          ]);
+        }));
+        created += fresh.length;
+        for (const ann of fresh) {
+          const body = ann.body;
+          const cat = Array.isArray(body) && typeof body[0]?.value === "string" ? body[0].value : "unknown";
+          byCategory[cat] = (byCategory[cat] ?? 0) + 1;
+        }
+        onProgress(60, { code: "creating-tag-annotations", count: created });
+        await onChunkComplete(fresh);
+      }
     );
-    completedItems.push({ value: category, foundCount: categoryTags.length });
-    allTags.push(...categoryTags);
-  }
-  const tags = allTags;
-  onProgress(60, { code: "creating-tag-annotations", count: tags.length });
-  const bodyLanguage = params.language ?? "en";
-  const annotations = dedupeAnnotations(tags.map((t) => {
-    const category = t.category ?? "unknown";
-    return buildAnnotation("tagging", t, [
-      { type: "TextualBody", value: category, purpose: "tagging", format: "text/plain", language: bodyLanguage },
-      { type: "TextualBody", value: params.schema.id, purpose: "classifying", format: "text/plain" }
-    ]);
-  }));
-  const byCategory = {};
-  for (const ann of annotations) {
-    const body = ann.body;
-    const category = Array.isArray(body) && typeof body[0]?.value === "string" ? body[0].value : "unknown";
-    byCategory[category] = (byCategory[category] ?? 0) + 1;
+    found += categoryFound;
+    completedItems.push({ value: category, foundCount: categoryFound });
   }
-  onProgress(100, { code: "complete-created", count: annotations.length, kind: "tag" });
+  onProgress(100, { code: "complete-created", count: created, kind: "tag" });
   return {
-    annotations,
-    result: { kind: "tag-annotation", tagsFound: tags.length, tagsCreated: annotations.length, byCategory }
+    result: { kind: "tag-annotation", tagsFound: found, tagsCreated: created, byCategory }
   };
 }
 function assertWithinOutputBudget(byteLength) {
@@ -2214,7 +2293,12 @@ var WORKER_AWAITED_OPERATIONS = [
   // P6). The worker AWAITS this one — a unit may not advance until its
   // annotations are in the event log — so its replies must be in the narrow
   // channel set or every commit fails fast with `bus.unsubscribed`.
-  "mark:commit"
+  "mark:commit",
+  // The durability probe for a commit whose acknowledgement never routed
+  // (COMMIT-ACK-FALSE-FAILURE F1). SINGULAR by design: the annotation LIST
+  // channel is the multi-MB fan-out this narrowing exists to keep out, and a
+  // rare error path is no reason to let it back in.
+  "browse:annotation-requested"
 ];
 replyChannelsFor(WORKER_AWAITED_OPERATIONS);