@semiont/jobs 0.5.28 → 0.5.30

package/dist/worker-main.js

@@ -1,14 +1,14 @@
-import { createTomlConfigLoader, didToAgent, baseUrl, STARTUP_FETCH_RETRY, retryWithBackoff, isTransientFetchError, busRequest, resourceId, getPrimaryMediaType, isGenerationJobParams, assembleAnnotation, findClaimSpan, textExtractionOf, reconcileSelector, GENERATABLE_MEDIA_TYPES, locate, createFragmentSelector, getLocaleEnglishName, estimateTokens, chunkText, isObject, isString, deriveViews } from '@semiont/core';
-import { anchoredTextStoreOverTransport, deriveStorageUri, extractPdfTextLayer, EXTRACTORS, calculateChecksum, withinByteBudget, MAX_PDF_BYTES } from '@semiont/content';
-import { withSpan, SpanKind, recordJobOutcome } from '@semiont/observability';
+import { replyChannelsFor, createTomlConfigLoader, didToAgent, baseUrl, STARTUP_FETCH_RETRY, retryWithBackoff, isTransientFetchError, isObject, isString, isNumber, busRequest, isArray, resourceId, getPrimaryMediaType, isGenerationJobParams, capabilitiesOf, assembleAnnotation, findClaimSpan, textExtractionOf, GENERATABLE_MEDIA_TYPES, locate, createFragmentSelector, deriveViews, estimateTokens, chunkText, reconcileSelector, getLocaleEnglishName } from '@semiont/core';
+import { archivistContentReads, extractPdfTextLayer, EXTRACTORS, calculateChecksum, withinByteBudget, MAX_PDF_BYTES } from '@semiont/content';
+import { withSpan, SpanKind, recordJobOutcome, recordAnchorOutcome, recordDetectionCall } from '@semiont/observability';
+import { createInferenceClient, StructuredReadError } from '@semiont/inference';
 import { execFileSync } from 'child_process';
 import { existsSync, readFileSync, mkdtempSync, writeFileSync, rmSync } from 'fs';
 import { homedir, hostname, tmpdir } from 'os';
 import { join } from 'path';
-import { generateAnnotationId } from '@semiont/event-sourcing';
-import { InMemorySessionStorage, setStoredSession, kbBackendUrl, SemiontClient, SemiontSession } from '@semiont/sdk';
+import { annotationIdFor } from '@semiont/event-sourcing';
+import { InMemorySessionStorage, setStoredSession, kbGatewayUrl, SemiontClient, SemiontSession } from '@semiont/sdk';
 import { HttpTransport, HttpContentTransport } from '@semiont/http-transport';
-import { createInferenceClient } from '@semiont/inference';
 import { createServer } from 'http';
 import { createProcessLogger } from '@semiont/observability/process-logger';
 
@@ -3766,9 +3766,9 @@ var require_mapOneOrManyArgs = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.mapOneOrManyArgs = void 0;
     var map_1 = require_map();
-    var isArray = Array.isArray;
+    var isArray2 = Array.isArray;
     function callOrApply(fn, args) {
-      return isArray(args) ? fn.apply(void 0, __spreadArray([], __read(args))) : fn(args);
+      return isArray2(args) ? fn.apply(void 0, __spreadArray([], __read(args))) : fn(args);
     }
     function mapOneOrManyArgs(fn) {
       return map_1.map(function(args) {
@@ -3913,14 +3913,14 @@ var require_argsArgArrayOrObject = __commonJS({
   "../../node_modules/rxjs/dist/cjs/internal/util/argsArgArrayOrObject.js"(exports) {
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.argsArgArrayOrObject = void 0;
-    var isArray = Array.isArray;
+    var isArray2 = Array.isArray;
     var getPrototypeOf = Object.getPrototypeOf;
     var objectProto = Object.prototype;
     var getKeys = Object.keys;
     function argsArgArrayOrObject(args) {
       if (args.length === 1) {
         var first_1 = args[0];
-        if (isArray(first_1)) {
+        if (isArray2(first_1)) {
           return { args: first_1, keys: null };
         }
         if (isPOJO(first_1)) {
@@ -4668,9 +4668,9 @@ var require_argsOrArgArray = __commonJS({
   "../../node_modules/rxjs/dist/cjs/internal/util/argsOrArgArray.js"(exports) {
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.argsOrArgArray = void 0;
-    var isArray = Array.isArray;
+    var isArray2 = Array.isArray;
     function argsOrArgArray(args) {
-      return args.length === 1 && isArray(args[0]) ? args[0] : args;
+      return args.length === 1 && isArray2(args[0]) ? args[0] : args;
     }
     exports.argsOrArgArray = argsOrArgArray;
   }
@@ -9208,6 +9208,8 @@ var require_cjs = __commonJS({
 
 // src/job-claim-adapter.ts
 var import_rxjs = __toESM(require_cjs());
+
+// src/worker-bus-primitive.ts
 function workerBusAsPrimitive(bus) {
   return {
     emit(channel, payload) {
@@ -9219,9 +9221,15 @@ function workerBusAsPrimitive(bus) {
     // Pass the real connection state through: a worker's first `job:claim`
     // fires right after connect — exactly the attach-window emit the gate
     // exists for (.plans/BUS-ATTACH-GATE.md).
-    state$: bus.state$
+    state$: bus.state$,
+    // Pass the subscription probe through so a request against a transport
+    // whose narrowed channel set omits the replies fails fast
+    // (`bus.unsubscribed`) instead of timing out.
+    ...bus.isSubscribed ? { isSubscribed: (channel) => bus.isSubscribed(channel) } : {}
   };
 }
+
+// src/job-claim-adapter.ts
 function createJobClaimAdapter(options) {
   const { bus, jobTypes } = options;
   const requestBus = workerBusAsPrimitive(bus);
@@ -9240,12 +9248,18 @@ function createJobClaimAdapter(options) {
   const claimJob = async (assignment) => {
     try {
       const job = await busRequest(requestBus, "job:claim", { jobId: assignment.jobId }, 1e4);
+      const completedUnits = isArray(job.metadata?.completedUnits) ? job.metadata.completedUnits.filter(isString) : [];
       return {
         jobId: assignment.jobId,
         type: assignment.type,
         resourceId: assignment.resourceId,
         userId: job.metadata?.userId ?? "",
-        params: job.params ?? {}
+        params: job.params ?? {},
+        completedUnits,
+        // Absent or malformed metadata reads as "no budget left" — a worker
+        // that cannot see the budget must not claim a retry is coming.
+        retryCount: isNumber(job.metadata?.retryCount) ? job.metadata.retryCount : 0,
+        maxRetries: isNumber(job.metadata?.maxRetries) ? job.metadata.maxRetries : 0
       };
     } catch {
       return null;
@@ -9330,6 +9344,11 @@ function createJobClaimAdapter(options) {
   };
 }
 
+// src/will-retry.ts
+function willRetryAfter(metadata, failureClass) {
+  return failureClass !== "deterministic" && metadata.retryCount < metadata.maxRetries;
+}
+
 // src/types.ts
 var JOB_TYPES = /* @__PURE__ */ new Set([
   "reference-annotation",
@@ -9349,6 +9368,9 @@ function asJobParams(params) {
   return params;
 }
 var INFERENCE_TIMEOUT_MS = 10 * 6e4;
+var InferenceTimeoutError = class extends Error {
+  name = "InferenceTimeoutError";
+};
 var INFERENCE_HEARTBEAT_MS = 15e3;
 function spanned(client, kind, maxTokens, work) {
   return withSpan(`inference:${kind}`, work, {
@@ -9359,12 +9381,20 @@ function spanned(client, kind, maxTokens, work) {
     }
   });
 }
-async function withTimeout(work, label, onHeartbeat) {
+async function withTimeout(work, meta, onHeartbeat, logger2) {
+  const controller = new AbortController();
   let timer;
   const timedOut = new Promise((_, reject) => {
     timer = setTimeout(() => {
-      reject(new Error(
-        `Inference call timed out after ${INFERENCE_TIMEOUT_MS / 6e4} minutes (${label}) \u2014 failing the job to keep the claim loop live`
+      logger2?.warn("Aborting in-flight inference call at the timeout bound", {
+        provider: meta.provider,
+        model: meta.model,
+        label: meta.label,
+        boundMs: INFERENCE_TIMEOUT_MS
+      });
+      controller.abort();
+      reject(new InferenceTimeoutError(
+        `Inference call timed out after ${INFERENCE_TIMEOUT_MS / 6e4} minutes (${meta.label}) \u2014 failing the job to keep the claim loop live`
       ));
     }, INFERENCE_TIMEOUT_MS);
     timer.unref?.();
@@ -9379,10 +9409,11 @@ async function withTimeout(work, label, onHeartbeat) {
     }, INFERENCE_HEARTBEAT_MS);
     heartbeat.unref?.();
   }
+  const pending = work(controller.signal);
   try {
-    return await Promise.race([work, timedOut]);
+    return await Promise.race([pending, timedOut]);
   } catch (err) {
-    work.catch(() => {
+    pending.catch(() => {
     });
     throw err;
   } finally {
@@ -9390,28 +9421,70 @@ async function withTimeout(work, label, onHeartbeat) {
     if (heartbeat) clearInterval(heartbeat);
   }
 }
-function boundedGenerateWithMetadata(client, prompt, maxTokens, temperature, onHeartbeat) {
+function boundedGenerateWithMetadata(client, prompt, maxTokens, temperature, onHeartbeat, logger2) {
   return spanned(client, "text", maxTokens, () => withTimeout(
-    client.generateTextWithMetadata(prompt, maxTokens, temperature),
-    `${client.type}:${client.modelId}`,
-    onHeartbeat
+    (signal) => client.generateTextWithMetadata(prompt, maxTokens, temperature, signal),
+    { provider: client.type, model: client.modelId, label: `${client.type}:${client.modelId}` },
+    onHeartbeat,
+    logger2
   ));
 }
-function boundedGenerateStructured(client, prompt, maxTokens, temperature, elementSchema, onHeartbeat) {
+function boundedGenerateStructured(client, prompt, maxTokens, temperature, elementSchema, onHeartbeat, logger2) {
   return spanned(client, "structured", maxTokens, () => withTimeout(
-    client.generateStructured(prompt, maxTokens, temperature, elementSchema),
-    `${client.type}:${client.modelId}`,
-    onHeartbeat
+    (signal) => client.generateStructured(prompt, maxTokens, temperature, elementSchema, signal),
+    { provider: client.type, model: client.modelId, label: `${client.type}:${client.modelId}` },
+    onHeartbeat,
+    logger2
   ));
 }
+var DeterministicJobError = class extends Error {
+  // Typed string, not the literal: subclasses (YieldCollapseError) carry
+  // their own name — classification is instanceof, never name-matching.
+  name = "DeterministicJobError";
+};
+function classifyFailure(error) {
+  if (error instanceof DeterministicJobError) return "deterministic";
+  if (error instanceof InferenceTimeoutError) return "transient";
+  if (error instanceof StructuredReadError && error.stopReason === "max_tokens") return "deterministic";
+  if (!isObject(error)) return void 0;
+  const name = isString(error.name) ? error.name : "";
+  if (name === "DeterministicJobError") return "deterministic";
+  if (name === "APIUserAbortError" || name === "AbortError") return "transient";
+  const status = isNumber(error.status) ? error.status : void 0;
+  if (status !== void 0) {
+    if (status === 408 || status === 429 || status >= 500) return "transient";
+    if (status >= 400) return "deterministic";
+  }
+  return void 0;
+}
 
 // src/workers/detection/detection-chunking.ts
+function assertNotTruncated(response, label, chunk, totalChunks, outputBudget) {
+  if (response.stopReason === "max_tokens") {
+    throw new DeterministicJobError(`${label} response truncated (max_tokens) on chunk ${chunk}/${totalChunks} despite the derived output budget of ${outputBudget} tokens \u2014 failing the job rather than under-reporting annotations.`);
+  }
+}
 var SELECTOR_CONTEXT_CHARS = 64;
 var OVERLAP_CHARS = SELECTOR_CONTEXT_CHARS + // prefix
 SELECTOR_CONTEXT_CHARS + // suffix
 2 * SELECTOR_CONTEXT_CHARS;
 var OVERLAP_TOKENS = Math.ceil(OVERLAP_CHARS / 4);
-function deriveDetectionBudget(limits, scaffoldTokens) {
+var DETECTION_TEMPERATURE = 0;
+var ASSUMED_OUTPUT_TOKENS_PER_HOUR = 108e3;
+var YIELD_COLLAPSE_BAND = 2;
+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 = []) {
+    super(message);
+    this.salvage = salvage;
+  }
+  salvage;
+  name = "YieldCollapseError";
+};
+function deriveDetectionBudget(limits, scaffoldTokens, typesPerCall) {
   const { contextTokens, maxOutputTokens } = limits;
   const available = contextTokens - scaffoldTokens;
   let inputBudget;
@@ -9427,6 +9500,15 @@ function deriveDetectionBudget(limits, scaffoldTokens) {
       outputBudget = available - inputBudget;
     }
   }
+  const outputTokensPerHour = limits.outputTokensPerHour ?? ASSUMED_OUTPUT_TOKENS_PER_HOUR;
+  {
+    const durationSafeOutput = Math.floor(outputTokensPerHour * (INFERENCE_TIMEOUT_MS / 2) / 36e5);
+    if (outputBudget > durationSafeOutput) {
+      inputBudget = Math.floor(inputBudget * (durationSafeOutput / outputBudget));
+      outputBudget = durationSafeOutput;
+    }
+  }
+  inputBudget = Math.min(inputBudget, Math.floor(outputBudget / (2 * typesPerCall)));
   if (inputBudget <= OVERLAP_TOKENS) {
     throw new Error(
       `Inference window too small for detection: context ${contextTokens} tokens minus scaffold ${scaffoldTokens} leaves an input budget of ${inputBudget} (need > ${OVERLAP_TOKENS}). Use a model with a larger context window or reduce the prompt scaffold.`
@@ -9437,6 +9519,91 @@ function deriveDetectionBudget(limits, scaffoldTokens) {
     outputBudget
   };
 }
+var MAX_SUBDIVISION_DEPTH = 2;
+function unknownUnreadable(error) {
+  return error instanceof StructuredReadError && error.stopReason === "unknown";
+}
+function subdividable(error) {
+  return error instanceof InferenceTimeoutError || truncation(error) || unknownUnreadable(error);
+}
+function truncation(error) {
+  return error instanceof DeterministicJobError || error instanceof StructuredReadError && error.stopReason === "max_tokens";
+}
+function outcomeOf(error) {
+  if (error instanceof YieldCollapseError) return "collapsed";
+  if (truncation(error)) return "truncated";
+  if (error instanceof InferenceTimeoutError) return "timeout";
+  return "error";
+}
+async function callChunkSubdividing(label, chunk, chunking, call, logger2) {
+  async function recorded(piece, depth, reroll) {
+    const start = performance.now();
+    try {
+      const result = await call(piece);
+      recordDetectionCall({
+        label,
+        pieceChars: piece.length,
+        durationMs: performance.now() - start,
+        items: result.items.length,
+        depth,
+        reroll,
+        outcome: "success",
+        ...result.usage ? { inputTokens: result.usage.inputTokens, outputTokens: result.usage.outputTokens } : {}
+      });
+      return result;
+    } catch (error) {
+      recordDetectionCall({
+        label,
+        pieceChars: piece.length,
+        durationMs: performance.now() - start,
+        items: 0,
+        depth,
+        reroll,
+        outcome: outcomeOf(error)
+      });
+      throw error;
+    }
+  }
+  async function attempt(piece, chunkSize, depth) {
+    try {
+      return (await recorded(piece, depth, false)).items;
+    } catch (error) {
+      if (!subdividable(error)) throw error;
+      const half = Math.floor(chunkSize / 2);
+      const pieces = chunkText(piece, { chunkSize: half, overlap: chunking.overlap });
+      const shrinks = pieces.length > 1 || pieces[0] !== piece;
+      const canDescend = shrinks && (truncation(error) || unknownUnreadable(error) ? half > 2 * OVERLAP_TOKENS : depth < MAX_SUBDIVISION_DEPTH);
+      if (!canDescend) {
+        if (error instanceof YieldCollapseError) {
+          logger2?.warn("Floor-size piece still flagged as collapsed \u2014 accepting its under-reported salvage and continuing", {
+            pieceChars: piece.length,
+            salvaged: error.salvage.length,
+            error: error.message
+          });
+          return error.salvage;
+        }
+        if (!truncation(error)) throw error;
+        logger2?.warn("Floor-size piece truncated \u2014 re-rolling once before giving up", {
+          pieceChars: piece.length,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return (await recorded(piece, depth, true)).items;
+      }
+      logger2?.warn("Chunk call failed at a size-shaped bound \u2014 subdividing and retrying smaller", {
+        depth: depth + 1,
+        pieceChars: piece.length,
+        nextChunkSizeTokens: half,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      const collected = [];
+      for (const p of pieces) {
+        collected.push(...await attempt(p, half, depth + 1));
+      }
+      return collected;
+    }
+  }
+  return attempt(chunk, chunking.chunkSize, 0);
+}
 function languageName(tag) {
   return getLocaleEnglishName(tag) || tag;
 }
@@ -9734,6 +9901,16 @@ Example format:
     return prompt;
   }
 };
+var DEGRADED = /* @__PURE__ */ new Set(["first-of-many", "fuzzy-match"]);
+function noteAnchor(label, exact, method, logger2) {
+  recordAnchorOutcome(label, method);
+  if (!DEGRADED.has(method)) return;
+  const detail = { text: exact, anchorMethod: method };
+  if (logger2) logger2.warn("Annotation anchored via degraded method", { label, ...detail });
+  else console.warn(`[${label}] anchored via ${method}: "${exact}"`);
+}
+
+// src/workers/detection/motivation-parsers.ts
 var COMMENT_ELEMENT_SCHEMA = {
   type: "object",
   properties: {
@@ -9922,35 +10099,31 @@ var MotivationParsers = class {
   }
 };
 function logAnchorMethod(motivation, exact, anchorMethod) {
-  if (anchorMethod === "first-of-many" || anchorMethod === "fuzzy-match") {
-    console.warn(`[MotivationParsers] ${motivation} anchored via ${anchorMethod}: "${exact}"`);
-  }
+  noteAnchor(motivation, exact, anchorMethod);
 }
 
 // src/workers/annotation-detection.ts
-function assertNotTruncated(response, motivation, chunk, totalChunks, outputBudget) {
-  if (response.stopReason === "max_tokens") {
-    throw new Error(`${motivation} detection response truncated (max_tokens) on chunk ${chunk}/${totalChunks} despite the derived output budget of ${outputBudget} tokens \u2014 failing the job rather than under-reporting annotations.`);
-  }
-}
-async function detectInChunks(client, content, buildPrompt, temperature, motivation, elementSchema, parse, onActivity) {
+async function detectInChunks(client, content, buildPrompt, motivation, elementSchema, parse, onActivity) {
   const limits = await client.limits();
   const scaffoldTokens = estimateTokens(buildPrompt(""));
-  const { chunking, outputBudget } = deriveDetectionBudget(limits, scaffoldTokens);
+  const { chunking, outputBudget } = deriveDetectionBudget(limits, scaffoldTokens, 1);
   const chunks = chunkText(content, chunking);
   const collected = [];
   for (let i = 0; i < chunks.length; i++) {
-    const response = await boundedGenerateStructured(
-      client,
-      buildPrompt(chunks[i]),
-      outputBudget,
-      temperature,
-      elementSchema,
-      // Still alive, same position (a long single call is otherwise silent).
-      () => onActivity?.(i, chunks.length)
-    );
-    assertNotTruncated(response, motivation, i + 1, chunks.length, outputBudget);
-    collected.push(...parse(response.items));
+    const items = await callChunkSubdividing(motivation, chunks[i], chunking, async (piece) => {
+      const response = await boundedGenerateStructured(
+        client,
+        buildPrompt(piece),
+        outputBudget,
+        DETECTION_TEMPERATURE,
+        elementSchema,
+        // Still alive, same position (a long single call is otherwise silent).
+        () => onActivity?.(i, chunks.length)
+      );
+      assertNotTruncated(response, `${motivation} detection`, i + 1, chunks.length, outputBudget);
+      return { items: response.items, ...response.usage ? { usage: response.usage } : {} };
+    });
+    collected.push(...parse(items));
     if (i < chunks.length - 1) {
       onActivity?.(i + 1, chunks.length);
     }
@@ -9971,7 +10144,6 @@ var AnnotationDetection = class {
       client,
       content,
       (chunk) => MotivationPrompts.buildCommentPrompt(chunk, instructions, tone, density, language, sourceLanguage),
-      0.4,
       "comment",
       COMMENT_ELEMENT_SCHEMA,
       (items) => MotivationParsers.parseComments(items, content),
@@ -9990,7 +10162,6 @@ var AnnotationDetection = class {
       client,
       content,
       (chunk) => MotivationPrompts.buildHighlightPrompt(chunk, instructions, density, sourceLanguage),
-      0.3,
       "highlight",
       HIGHLIGHT_ELEMENT_SCHEMA,
       (items) => MotivationParsers.parseHighlights(items, content),
@@ -10009,7 +10180,6 @@ var AnnotationDetection = class {
       client,
       content,
       (chunk) => MotivationPrompts.buildAssessmentPrompt(chunk, instructions, tone, density, language, sourceLanguage),
-      0.3,
       "assessment",
       ASSESSMENT_ELEMENT_SCHEMA,
       (items) => MotivationParsers.parseAssessments(items, content),
@@ -10046,7 +10216,6 @@ var AnnotationDetection = class {
         categoryInfo.examples,
         sourceLanguage
       ),
-      0.2,
       "tag",
       TAG_ELEMENT_SCHEMA,
       (items) => MotivationParsers.parseTags(items),
@@ -10066,6 +10235,40 @@ var ENTITY_ELEMENT_SCHEMA = {
   required: ["exact", "entityType"],
   additionalProperties: false
 };
+var COUNT_MAX_TOKENS = 16;
+function parseCount(text) {
+  const m = text.trim().match(/\d+/);
+  return m ? Number(m[0]) : void 0;
+}
+async function assertYieldNotCollapsed(client, piece, items, entityTypesDescription, logger2) {
+  const prompt = `Count every mention of: ${entityTypesDescription} in the following text. Repeated mentions of the same entity count separately. Respond with only the number.
+
+Text:
+"""
+${piece}
+"""`;
+  let counted;
+  try {
+    const response = await boundedGenerateWithMetadata(client, prompt, COUNT_MAX_TOKENS, DETECTION_TEMPERATURE, void 0, logger2);
+    counted = parseCount(response.text);
+  } catch (err) {
+    logger2.warn("Count-verifier call failed \u2014 yield check skipped for this chunk", {
+      pieceChars: piece.length,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return;
+  }
+  if (counted === void 0) {
+    logger2.warn("Count-verifier answer carried no number \u2014 yield check skipped for this chunk", { pieceChars: piece.length });
+    return;
+  }
+  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]
+    );
+  }
+}
 async function extractEntities(exact, entityTypes, client, includeDescriptiveReferences, logger2, sourceLanguage, onActivity) {
   const entityTypesDescription = entityTypes.map((et) => {
     if (typeof et === "string") {
@@ -10116,8 +10319,9 @@ If no entities are found, respond with an empty array [].
 Example output:
 [{"exact":"Alice","entityType":"Person","prefix":"","suffix":" went to"},{"exact":"Paris","entityType":"Location","prefix":"went to ","suffix":" yesterday"}]`;
   const limits = await client.limits();
+  const verifyYield = client.verifyDetectionYield;
   const scaffoldTokens = estimateTokens(buildPrompt(""));
-  const { chunking, outputBudget } = deriveDetectionBudget(limits, scaffoldTokens);
+  const { chunking, outputBudget } = deriveDetectionBudget(limits, scaffoldTokens, entityTypes.length);
   const chunks = chunkText(exact, chunking);
   logger2.debug("Sending entity extraction request", {
     entityTypes: entityTypesDescription,
@@ -10127,28 +10331,31 @@ Example output:
   });
   const collected = [];
   for (let i = 0; i < chunks.length; i++) {
-    const response = await boundedGenerateStructured(
-      client,
-      buildPrompt(chunks[i]),
-      outputBudget,
-      0.3,
-      // Lower temperature for more consistent extraction
-      ENTITY_ELEMENT_SCHEMA,
-      // Still alive, same position: a long single call would otherwise emit
-      // nothing at all between start and finish.
-      () => onActivity?.(i, chunks.length)
-    );
-    logger2.debug("Got entity extraction response", {
-      chunk: i + 1,
-      chunks: chunks.length,
-      items: response.items.length
-    });
-    if (response.stopReason === "max_tokens") {
-      const errorMsg = `Entity extraction response truncated (max_tokens) on chunk ${i + 1}/${chunks.length} despite the derived output budget of ${outputBudget} tokens \u2014 failing the job rather than dropping annotations.`;
-      logger2.error(errorMsg, { items: response.items.length });
-      throw new Error(errorMsg);
-    }
-    for (const e of response.items) {
+    const items = await callChunkSubdividing("reference", chunks[i], chunking, async (piece) => {
+      const response = await boundedGenerateStructured(
+        client,
+        buildPrompt(piece),
+        outputBudget,
+        DETECTION_TEMPERATURE,
+        ENTITY_ELEMENT_SCHEMA,
+        // Still alive, same position: a long single call would otherwise emit
+        // nothing at all between start and finish.
+        () => onActivity?.(i, chunks.length),
+        logger2
+      );
+      logger2.debug("Got entity extraction response", {
+        chunk: i + 1,
+        chunks: chunks.length,
+        pieceChars: piece.length,
+        items: response.items.length
+      });
+      assertNotTruncated(response, "Entity extraction", i + 1, chunks.length, outputBudget);
+      if (verifyYield) {
+        await assertYieldNotCollapsed(client, piece, response.items, entityTypesDescription, logger2);
+      }
+      return { items: response.items, ...response.usage ? { usage: response.usage } : {} };
+    }, logger2);
+    for (const e of items) {
       if (isObject(e) && isString(e.exact) && isString(e.entityType)) {
         collected.push({
           exact: e.exact,
@@ -10379,7 +10586,7 @@ ${formatRequirements}`;
     temperature: finalTemperature,
     maxTokens: finalMaxTokens
   });
-  const response = await boundedGenerateWithMetadata(client, prompt, finalMaxTokens, finalTemperature);
+  const response = await boundedGenerateWithMetadata(client, prompt, finalMaxTokens, finalTemperature, void 0, logger2);
   logger2.debug("Got response from inference", { responseLength: response.text.length, stopReason: response.stopReason });
   const result = parseResponse(response.text);
   logger2.debug("Parsed response", {
@@ -10474,6 +10681,27 @@ function resolveCitationTokens(content, validResourceIds, logger2) {
   clean += content.slice(last);
   return { content: clean, citations };
 }
+
+// src/workers/detection/bounded-concurrency.ts
+async function runBounded(items, limit, worker) {
+  const results = new Array(items.length);
+  let next = 0;
+  async function pump() {
+    while (true) {
+      const i = next++;
+      if (i >= items.length) return;
+      results[i] = await worker(items[i], i);
+    }
+  }
+  const poolSize = Math.max(1, Math.min(limit, items.length));
+  await Promise.all(Array.from({ length: poolSize }, () => pump()));
+  return results;
+}
+
+// src/processors.ts
+function spanAnchor(match) {
+  return `${match.start}:${match.end}:${match.exact}`;
+}
 function toMatch(r) {
   return {
     exact: r.exact,
@@ -10535,7 +10763,7 @@ function buildTextAnnotation(content, resourceId, userId, generator, motivation,
   return {
     "@context": "http://www.w3.org/ns/anno.jsonld",
     "type": "Annotation",
-    "id": generateAnnotationId(),
+    "id": annotationIdFor({ resourceId, motivation, anchor: spanAnchor(match), body }),
     motivation,
     creator,
     generator,
@@ -10574,7 +10802,7 @@ function buildPdfAnnotation(anchored, resourceId, userId, generator, motivation,
   return {
     "@context": "http://www.w3.org/ns/anno.jsonld",
     "type": "Annotation",
-    "id": generateAnnotationId(),
+    "id": annotationIdFor({ resourceId, motivation, anchor: spanAnchor(match), body }),
     motivation,
     creator,
     generator,
@@ -10703,31 +10931,33 @@ async function processAssessmentJob(content, inferenceClient, params, buildAnnot
     result: { kind: "assessment-annotation", assessmentsFound: assessments.length, assessmentsCreated: annotations.length }
   };
 }
-async function processReferenceJob(content, inferenceClient, params, buildAnnotation, onProgress, logger2) {
+async function processReferenceJob(content, inferenceClient, params, buildAnnotation, onProgress, logger2, onUnitComplete, signal) {
   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;
-  const allAnnotations = [];
   onProgress(10, { code: "loading" }, { requestParams });
   const bodyLanguage = params.language ?? "en";
-  for (let i = 0; i < entityTypeNames.length; i++) {
-    const entityTypeName = entityTypeNames[i];
-    if (!entityTypeName) continue;
-    const pct = 20 + Math.round(i / entityTypeNames.length * 60);
+  let completed = 0;
+  const total = entityTypeNames.length;
+  const emitTypeProgress = (entityTypeName) => {
+    const pct = 20 + Math.round(completed / total * 60);
     onProgress(pct, { code: "detecting-entities", entityType: entityTypeName }, {
-      // One vocabulary for "what is in flight" (CLEAN-PROGRESS D2): the entity
-      // type is KB data, `kind` is the code the client localizes around it.
       current: { kind: "entity-type", value: entityTypeName },
-      processed: i,
-      total: entityTypeNames.length,
+      processed: completed,
+      total,
       entitiesFound: totalFound,
       entitiesEmitted: totalEmitted,
       completedItems: [...completedItems],
       requestParams
     });
+  };
+  await runBounded(entityTypeNames, inferenceClient.maxConcurrency, async (entityTypeName) => {
+    if (!entityTypeName) return;
+    if (signal?.aborted) return;
+    emitTypeProgress(entityTypeName);
     const extractedEntities = await extractEntities(
       content,
       [entityTypeName],
@@ -10735,31 +10965,17 @@ async function processReferenceJob(content, inferenceClient, params, buildAnnota
       params.includeDescriptiveReferences ?? false,
       logger2,
       params.sourceLanguage,
-      // Liveness: fires at chunk boundaries AND every ~15 s while a single
-      // inference call is in flight (DETECTION-HEARTBEAT). Progress feeds the
-      // stall watchdog, the janitor, AND the client's inter-emission timeout,
-      // so a long single-chunk call must not be silent. Percentage
-      // interpolates within this entity type's band of the 20–80 range; a
-      // heartbeat repeats the current position rather than inventing an
-      // advance.
-      (completed, total) => {
-        const interpolated = 20 + Math.round((i + completed / total) / entityTypeNames.length * 60);
-        onProgress(interpolated, { code: "detecting-entities", entityType: entityTypeName }, {
-          current: { kind: "entity-type", value: entityTypeName },
-          processed: i,
-          total: entityTypeNames.length,
-          entitiesFound: totalFound,
-          entitiesEmitted: totalEmitted,
-          completedItems: [...completedItems],
-          requestParams
-        });
-      }
+      // Liveness heartbeat (DETECTION-HEARTBEAT): fires at chunk boundaries and
+      // every ~15 s while a call is in flight, so a long single-chunk call is
+      // 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)
     );
-    totalFound += extractedEntities.length;
-    completedItems.push({ value: entityTypeName, foundCount: extractedEntities.length });
     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,
@@ -10774,23 +10990,28 @@ async function processReferenceJob(content, inferenceClient, params, buildAnnota
         errors++;
         continue;
       }
-      if (reconciled.anchorMethod === "first-of-many" || reconciled.anchorMethod === "fuzzy-match") {
-        logger2.warn("Entity anchored via degraded method", {
-          text: entity.exact,
-          entityType: entity.entityType,
-          anchorMethod: reconciled.anchorMethod
-        });
-      }
+      noteAnchor("reference", entity.exact, reconciled.anchorMethod, logger2);
       const ann = buildAnnotation("linking", toMatch(reconciled), unresolvedBody);
-      allAnnotations.push(ann);
-      totalEmitted++;
+      built.push(ann);
     }
-  }
-  const annotations = dedupeAnnotations(allAnnotations);
-  onProgress(100, { code: "complete-created", count: annotations.length, kind: "reference" }, { requestParams });
+    const unitAnnotations = dedupeAnnotations(built);
+    await onUnitComplete(entityTypeName, unitAnnotations);
+    totalEmitted += unitAnnotations.length;
+    totalFound += extractedEntities.length;
+    completedItems.push({
+      value: entityTypeName,
+      foundCount: extractedEntities.length,
+      persistedCount: unitAnnotations.length
+    });
+    completed++;
+    emitTypeProgress(entityTypeName);
+  });
+  onProgress(100, { code: "complete-created", count: totalEmitted, kind: "reference" }, {
+    completedItems: [...completedItems],
+    requestParams
+  });
   return {
-    annotations,
-    result: { kind: "reference-annotation", totalFound, totalEmitted: annotations.length, errors }
+    result: { kind: "reference-annotation", totalFound, totalEmitted, errors }
   };
 }
 async function processTagJob(content, inferenceClient, params, buildAnnotation, onProgress) {
@@ -10995,10 +11216,10 @@ async function processGenerationJob(inferenceClient, params, onProgress, logger2
 }
 
 // src/workers/detection/prepare-detection.ts
-async function prepareDetection(mediaType, session, resourceId, userId, generator, store) {
+async function prepareDetection(mediaType, content, resourceId, userId, generator, store) {
   const extractor = EXTRACTORS[textExtractionOf(mediaType)];
   if (!extractor) return { declined: "no-extractor" };
-  const { data } = await session.client.browse.resourceRepresentation(resourceId);
+  const { data } = await content.getBinary(resourceId);
   const bytes = Buffer.from(data);
   const extracted = await extractor.extract(bytes, mediaType, {
     key: calculateChecksum(bytes),
@@ -11031,6 +11252,16 @@ function referenceIdOf(job) {
   const ref = job.params.referenceId;
   return typeof ref === "string" ? ref : void 0;
 }
+var MARK_COMMIT_TIMEOUT_MS = 6e4;
+async function commitAnnotations(session, resourceId, annotations) {
+  if (annotations.length === 0) return;
+  await busRequest(
+    workerBusAsPrimitive(session.client.transport.actor),
+    "mark:commit",
+    { resourceId, annotations },
+    MARK_COMMIT_TIMEOUT_MS
+  );
+}
 async function emitEvent(session, channel, payload) {
   await session.client.transport.emit(channel, payload);
 }
@@ -11041,12 +11272,29 @@ function startWorkerProcess(config) {
     bus: httpTransport.actor,
     jobTypes: config.jobTypes
   });
+  const completedUnitsByJob = /* @__PURE__ */ new Map();
+  let activeCancel = null;
+  httpTransport.actor.addChannels?.(["job:cancel-requested"]);
+  httpTransport.on("job:cancel-requested", (event) => {
+    const targetId = event.jobId;
+    if (targetId && activeCancel?.jobId === targetId) {
+      logger2.info("Cancel requested for active job \u2014 stopping at next unit boundary", { jobId: targetId });
+      activeCancel.controller.abort();
+    }
+  });
   adapter.activeJob$.subscribe((job) => {
     if (!job) return;
     logger2.info("Processing job", { jobId: job.jobId, type: job.type, resourceId: job.resourceId });
-    handleJob(adapter, config, job).catch((error) => {
+    const controller = new AbortController();
+    activeCancel = { jobId: job.jobId, controller };
+    handleJob(adapter, config, job, completedUnitsByJob, controller.signal).then(() => {
+      completedUnitsByJob.delete(job.jobId);
+    }).catch((error) => {
       const message = error instanceof Error ? error.message : String(error);
-      logger2.error("Job failed", { jobId: job.jobId, error: message, stack: error instanceof Error ? error.stack : void 0 });
+      const failureClass = classifyFailure(error);
+      logger2.error("Job failed", { jobId: job.jobId, error: message, failureClass, stack: error instanceof Error ? error.stack : void 0 });
+      const completedUnits = completedUnitsByJob.get(job.jobId);
+      completedUnitsByJob.delete(job.jobId);
       const failAnnotationId = referenceIdOf(job);
       if (isJobType(job.type)) {
         emitEvent(session, "job:fail", {
@@ -11054,23 +11302,33 @@ function startWorkerProcess(config) {
           jobId: job.jobId,
           jobType: job.type,
           ...failAnnotationId ? { annotationId: failAnnotationId } : {},
-          error: message
+          error: message,
+          ...completedUnits && completedUnits.length > 0 ? { completedUnits } : {},
+          ...failureClass !== void 0 ? { failureClass } : {},
+          // Whether this failure is the END, answered by the same predicate
+          // the queue applies at failJob (JOB-RESTART-SAFETY P5). Without
+          // it a client cannot tell a recovering run from a dead one: it
+          // sees job:fail either way and would end its stream on a job the
+          // queue is about to re-run.
+          willRetry: willRetryAfter(job, failureClass)
         }).catch(() => {
         });
       }
       adapter.failJob(job.jobId, message);
+    }).finally(() => {
+      if (activeCancel?.jobId === job.jobId) activeCancel = null;
     });
   });
   adapter.start();
   return adapter;
 }
-async function handleJob(adapter, config, job) {
+async function handleJob(adapter, config, job, completedUnitsByJob = /* @__PURE__ */ new Map(), signal) {
   const start = performance.now();
   let outcome = "completed";
   try {
     return await withSpan(
       `job:${job.type}`,
-      () => handleJobInner(adapter, config, job),
+      () => handleJobInner(adapter, config, job, completedUnitsByJob, signal),
       {
         kind: SpanKind.CONSUMER,
         attrs: {
@@ -11087,7 +11345,7 @@ async function handleJob(adapter, config, job) {
     recordJobOutcome(job.type, outcome, performance.now() - start);
   }
 }
-async function handleJobInner(adapter, config, job) {
+async function handleJobInner(adapter, config, job, completedUnitsByJob, signal) {
   const { session, inferenceClient, generator } = config;
   const { userId, jobId } = job;
   if (!isJobType(job.type)) {
@@ -11114,12 +11372,12 @@ async function handleJobInner(adapter, config, job) {
     const mediaType = getPrimaryMediaType(descriptor);
     const source = await withSpan(
       "detection:prepare",
-      () => prepareDetection(mediaType ?? "", session, resourceId$1, userId, generator, config.anchoredTextStore),
+      () => prepareDetection(mediaType ?? "", config.contentReads, resourceId$1, userId, generator, config.anchoredTextStore),
       { attrs: { "resource.id": resourceId$1, "media.type": mediaType ?? "unknown" } }
     );
     if ("declined" in source) {
       if (source.declined === "no-extractor") {
-        throw new Error(`Cannot run ${jobType} on resource ${resourceId$1}: media type '${mediaType ?? "unknown"}' has no extractable text to analyze`);
+        throw new DeterministicJobError(`Cannot run ${jobType} on resource ${resourceId$1}: media type '${mediaType ?? "unknown"}' has no extractable text to analyze`);
       }
       await emitEvent(session, "job:complete", {
         ...lifecycleBase,
@@ -11156,9 +11414,7 @@ async function handleJobInner(adapter, config, job) {
       ready.buildAnnotation,
       onProgress
     );
-    for (const ann of annotations) {
-      await emitEvent(session, "mark:create", { annotation: ann, resourceId: resourceId$1 });
-    }
+    await commitAnnotations(session, String(resourceId$1), annotations);
     await emitEvent(session, "job:complete", {
       ...lifecycleBase,
       result
@@ -11172,9 +11428,7 @@ async function handleJobInner(adapter, config, job) {
       ready.buildAnnotation,
       onProgress
     );
-    for (const ann of annotations) {
-      await emitEvent(session, "mark:create", { annotation: ann, resourceId: resourceId$1 });
-    }
+    await commitAnnotations(session, String(resourceId$1), annotations);
     await emitEvent(session, "job:complete", {
       ...lifecycleBase,
       result
@@ -11188,25 +11442,45 @@ async function handleJobInner(adapter, config, job) {
       ready.buildAnnotation,
       onProgress
     );
-    for (const ann of annotations) {
-      await emitEvent(session, "mark:create", { annotation: ann, resourceId: resourceId$1 });
-    }
+    await commitAnnotations(session, String(resourceId$1), annotations);
     await emitEvent(session, "job:complete", {
       ...lifecycleBase,
       result
     });
     adapter.completeJob();
   } else if (jobType === "reference-annotation") {
-    const { annotations, result } = await processReferenceJob(
+    const params = asJobParams(job.params);
+    const skip = new Set(job.completedUnits);
+    const remaining = {
+      ...params,
+      entityTypes: params.entityTypes.filter((t) => !skip.has(String(t)))
+    };
+    const committed = [];
+    completedUnitsByJob.set(job.jobId, committed);
+    const { result } = await processReferenceJob(
       ready.text,
       inferenceClient,
-      asJobParams(job.params),
+      remaining,
       ready.buildAnnotation,
       onProgress,
-      config.logger
+      config.logger,
+      async (unit, annotations) => {
+        await commitAnnotations(session, String(resourceId$1), annotations);
+        committed.push(unit);
+        await emitEvent(session, "job:checkpoint", {
+          jobId: job.jobId,
+          completedUnits: [...committed]
+        });
+      },
+      signal
     );
-    for (const ann of annotations) {
-      await emitEvent(session, "mark:create", { annotation: ann, resourceId: resourceId$1 });
+    if (signal?.aborted) {
+      await emitEvent(session, "job:cancel", {
+        ...lifecycleBase,
+        ...committed.length > 0 ? { completedUnits: [...committed] } : {}
+      });
+      adapter.completeJob();
+      return;
     }
     await emitEvent(session, "job:complete", {
       ...lifecycleBase,
@@ -11221,9 +11495,7 @@ async function handleJobInner(adapter, config, job) {
       ready.buildAnnotation,
       onProgress
     );
-    for (const ann of annotations) {
-      await emitEvent(session, "mark:create", { annotation: ann, resourceId: resourceId$1 });
-    }
+    await commitAnnotations(session, String(resourceId$1), annotations);
     await emitEvent(session, "job:complete", {
       ...lifecycleBase,
       result
@@ -11243,7 +11515,16 @@ async function handleJobInner(adapter, config, job) {
     );
     const genParams = job.params;
     const genReferenceId = referenceIdOf(job);
-    const storageUri = deriveStorageUri(genResult.title, genResult.format);
+    const storageUri = job.params.storageUri;
+    const expectedExtension = capabilitiesOf(genResult.format)?.extension;
+    if (expectedExtension && !storageUri.toLowerCase().endsWith(expectedExtension)) {
+      config.logger.warn("Storage URI extension does not match the generated format \u2014 writing it as requested", {
+        jobId,
+        storageUri,
+        format: genResult.format,
+        expectedExtension
+      });
+    }
     const { resourceId: newResourceId } = await session.client.yield.resource({
       name: genResult.title,
       file: Buffer.from(genResult.content),
@@ -11265,8 +11546,9 @@ async function handleJobInner(adapter, config, job) {
         },
         generator
       );
-      await emitEvent(session, "mark:create", { annotation: provenanceRef, resourceId: resourceId$1 });
+      await commitAnnotations(session, String(resourceId$1), [provenanceRef]);
     }
+    const citationRefs = [];
     if (genResult.format === "application/pdf" && genResult.citations.length > 0) {
       const layer = await extractPdfTextLayer(genResult.content);
       if (!layer) {
@@ -11296,7 +11578,7 @@ async function handleJobInner(adapter, config, job) {
             { exact: layer.text.slice(span.start, span.end), start: span.start, end: span.end },
             { type: "SpecificResource", source: citation.resourceId, purpose: "linking" }
           );
-          await emitEvent(session, "mark:create", { annotation: citationRef, resourceId: newResourceId });
+          citationRefs.push(citationRef);
         }
       }
     } else {
@@ -11315,9 +11597,10 @@ async function handleJobInner(adapter, config, job) {
           },
           generator
         );
-        await emitEvent(session, "mark:create", { annotation: citationRef, resourceId: newResourceId });
+        citationRefs.push(citationRef);
       }
     }
+    await commitAnnotations(session, String(newResourceId), citationRefs);
     await emitEvent(session, "job:complete", {
       ...lifecycleBase,
       result: { kind: "generation", resourceId: newResourceId, resourceName: genResult.title, truncated: genResult.result.truncated }
@@ -11328,6 +11611,29 @@ async function handleJobInner(adapter, config, job) {
   }
 }
 
+// src/anchored-text-over-bus.ts
+function anchoredTextOverBus(client, logger2) {
+  return {
+    async read(key) {
+      try {
+        return await client.browse.anchoredTextByChecksum(key);
+      } catch (error) {
+        logger2?.debug("Anchored-text consult failed \u2014 treating as miss", {
+          key,
+          reason: error instanceof Error ? error.message : String(error)
+        });
+        return null;
+      }
+    },
+    async write(key) {
+      logger2?.debug("Anchored-text write skipped \u2014 the Smelter is the sole writer", { key });
+    },
+    async list() {
+      return [];
+    }
+  };
+}
+
 // src/worker-runtime.ts
 var import_rxjs2 = __toESM(require_cjs());
 function buildHealthPayload(workers) {
@@ -11367,7 +11673,18 @@ function startStallWatchdog(opts) {
   timer.unref?.();
   return { dispose: () => clearInterval(timer) };
 }
-function parseBackendUrl(url) {
+var WORKER_AWAITED_OPERATIONS = [
+  "job:claim",
+  "browse:resource-requested",
+  "browse:anchored-text-by-checksum-requested",
+  // Durability acknowledgement for a unit's annotations (JOB-RESTART-SAFETY
+  // 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"
+];
+var WORKER_CHANNELS = replyChannelsFor(WORKER_AWAITED_OPERATIONS);
+function parseGatewayUrl(url) {
   const parsed = new URL(url);
   const protocol = parsed.protocol.replace(":", "") === "https" ? "https" : "http";
   const host = parsed.hostname;
@@ -11375,13 +11692,13 @@ function parseBackendUrl(url) {
   return { protocol, host, port };
 }
 async function authenticateAgent(opts) {
-  const { backendBaseUrl: backendBaseUrl2, workerSecret: workerSecret2, provider, model, logger: logger2, retry = STARTUP_FETCH_RETRY } = opts;
+  const { gatewayBaseUrl: gatewayBaseUrl2, workerSecret: workerSecret2, provider, model, logger: logger2, retry = STARTUP_FETCH_RETRY } = opts;
   if (!workerSecret2) {
     throw new Error("SEMIONT_WORKER_SECRET is required to authenticate worker agents");
   }
   return retryWithBackoff(
     async () => {
-      const response = await fetch(`${backendBaseUrl2}/api/tokens/agent`, {
+      const response = await fetch(`${gatewayBaseUrl2}/api/tokens/agent`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ secret: workerSecret2, provider, model })
@@ -11394,7 +11711,7 @@ async function authenticateAgent(opts) {
     isTransientFetchError,
     retry,
     ({ attempt, attempts, delayMs, error }) => {
-      logger2?.warn("Backend unreachable, retrying agent authentication", {
+      logger2?.warn("Gateway unreachable, retrying agent authentication", {
         agent: `${provider}:${model}`,
         attempt,
         attempts,
@@ -11405,11 +11722,11 @@ async function authenticateAgent(opts) {
   );
 }
 async function startAgentWorker(opts) {
-  const { group, backendBaseUrl: backendBaseUrl2, workerSecret: workerSecret2, logger: logger2 } = opts;
+  const { group, gatewayBaseUrl: gatewayBaseUrl2, workerSecret: workerSecret2, contentReads: contentReads2, logger: logger2 } = opts;
   const { inference } = group;
-  const { protocol, host, port } = parseBackendUrl(backendBaseUrl2);
+  const { protocol, host, port } = parseGatewayUrl(gatewayBaseUrl2);
   const { token: initialToken, did } = await authenticateAgent({
-    backendBaseUrl: backendBaseUrl2,
+    gatewayBaseUrl: gatewayBaseUrl2,
     workerSecret: workerSecret2,
     provider: inference.type,
     model: inference.model,
@@ -11429,9 +11746,12 @@ async function startAgentWorker(opts) {
   const token$ = new import_rxjs2.BehaviorSubject(null);
   let session;
   const transport = new HttpTransport({
-    baseUrl: baseUrl(kbBackendUrl(endpoint)),
+    baseUrl: baseUrl(kbGatewayUrl(endpoint)),
     token$,
-    tokenRefresher: () => session.refresh().then((t) => t ?? null)
+    tokenRefresher: () => session.refresh().then((t) => t ?? null),
+    // Only the reply channels this process awaits — not the full bridged
+    // set. See WORKER_AWAITED_OPERATIONS.
+    channels: WORKER_CHANNELS
   });
   const content = new HttpContentTransport(transport);
   const client = new SemiontClient(transport, content, transport);
@@ -11443,7 +11763,7 @@ async function startAgentWorker(opts) {
     refresh: async () => {
       try {
         const { token } = await authenticateAgent({
-          backendBaseUrl: backendBaseUrl2,
+          gatewayBaseUrl: gatewayBaseUrl2,
           workerSecret: workerSecret2,
           provider: inference.type,
           model: inference.model,
@@ -11468,10 +11788,12 @@ async function startAgentWorker(opts) {
     jobTypes: group.jobTypes,
     inferenceClient: group.client,
     generator,
-    // The extraction seam's cache, over this worker's content transport
-    // (PERSIST-ANCHORS P2d). Built here because the client keeps its
-    // content transport private — this is where it is in hand.
-    anchoredTextStore: anchoredTextStoreOverTransport(content, logger2),
+    // The extraction seam's cache, consulted over the bus and never written
+    // (ANCHORED-TEXT-TO-SMELTER D2): the Smelter owns this store, the
+    // Archivist answers the checksum-addressed read, and a worker that
+    // misses extracts locally and discards.
+    anchoredTextStore: anchoredTextOverBus(client, logger2),
+    contentReads: contentReads2,
     logger: logger2
   });
   logger2.info("Agent ready", {
@@ -11527,13 +11849,14 @@ function resolveWorker(jobType) {
     `No inference config for worker '${jobType}' and no workers.default in ~/.semiontconfig.`
   );
 }
-var backendPublicURL = envConfig.services?.backend?.publicURL;
-if (!backendPublicURL) {
-  throw new Error("services.backend.publicURL is required in ~/.semiontconfig");
+var gatewayPublicURL = envConfig.services?.gateway?.publicURL;
+if (!gatewayPublicURL) {
+  throw new Error("services.gateway.publicURL is required in ~/.semiontconfig");
 }
-var backendBaseUrl = backendPublicURL;
+var gatewayBaseUrl = gatewayPublicURL;
 var workerSecret = process.env.SEMIONT_WORKER_SECRET ?? "";
-var healthPort = 9090;
+var contentReads = archivistContentReads(envConfig);
+var healthPort = 24100;
 var logger = createProcessLogger("worker");
 function clientKey(w) {
   return [w.type, w.model, w.apiKey ?? "", w.endpoint ?? "", w.baseURL ?? ""].join("|");
@@ -11566,7 +11889,7 @@ async function main() {
   const { initObservabilityNode } = await import('@semiont/observability/node');
   initObservabilityNode({ serviceName: "semiont-worker" });
   logger.info("Starting agents", {
-    baseUrl: backendBaseUrl,
+    baseUrl: gatewayBaseUrl,
     agents: Array.from(groups.values()).map((g) => ({
       provider: g.inference.type,
       model: g.inference.model,
@@ -11575,7 +11898,7 @@ async function main() {
   });
   const workers = await Promise.all(
     Array.from(groups.values()).map(
-      (group) => startAgentWorker({ group, backendBaseUrl, workerSecret, logger })
+      (group) => startAgentWorker({ group, gatewayBaseUrl, workerSecret, contentReads, logger })
     )
   );
   const health = createServer((req, res) => {