@semiont/make-meaning 0.5.32 → 0.5.34

package/dist/archivist-main.js

@@ -1,5 +1,5 @@
 import { HttpTransport } from '@semiont/http-transport';
-import { replyChannelsFor, accessToken, EventBus, baseUrl as baseUrl$1, errField, PERSISTED_EVENT_TYPES, retryWithBackoff, isTransientFetchError, STARTUP_FETCH_RETRY, userId, resourceId, generateUuid, annotationId, getBodySource, getTargetSource, getTargetSelector, getExactText, getStorageUri, cloneToken, getResourceEntityTypes, didToAgent, assembleAnnotation, busRequest, getPrimaryRepresentation, decodeRepresentation, getResourceId, deriveViews, getTextPositionSelector, isAnnotatable, softwareToAgent } from '@semiont/core';
+import { replyChannelsFor, accessToken, EventBus, withDeadline, baseUrl as baseUrl$1, errField, PERSISTED_EVENT_TYPES, retryWithBackoff, isTransientFetchError, STARTUP_FETCH_RETRY, userId, resourceId, generateUuid, annotationId, getBodySource, getTargetSource, getTargetSelector, getExactText, getStorageUri, cloneToken, getResourceEntityTypes, didToAgent, assembleAnnotation, busRequest, getPrimaryRepresentation, decodeRepresentation, getResourceId, deriveViews, getTextPositionSelector, isAnnotatable, softwareToAgent } from '@semiont/core';
 import { loadEnvironmentConfig, SemiontProject } from '@semiont/core/node';
 import { createEventStore, resolveStorageUri, EventQuery } from '@semiont/event-sourcing';
 import { WorkingTreeStore, createAnchoredTextStore, RepresentationMissing, ChecksumMismatchError } from '@semiont/content';
@@ -13,6 +13,7 @@ import { createInferenceClient } from '@semiont/inference';
 import { createServer } from 'http';
 import { pipeline } from 'stream/promises';
 import { createProcessLogger } from '@semiont/observability/process-logger';
+import '@semiont/jobs';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -10047,36 +10048,56 @@ var Stower = class {
    *
    * Appends are sequential, not concurrent: the event log is the system of
    * record and a batch that half-lands under concurrency is harder to reason
-   * about than one that stops at the first failure. A partial batch is
-   * reported as a failure and the worker retries the WHOLE unit, which is safe
-   * because ids are deterministic (P3) and the annotation fold is idempotent
-   * by id — re-appending what already landed changes nothing.
+   * about than one that stops at the first failure.
+   *
+   * This channel is AT-LEAST-ONCE, and the log must not grow on a repeat
+   * (COMMIT-ACK-FALSE-FAILURE F3). Two paths re-send a batch that already
+   * landed: an acknowledgement lost after a successful append (the unit is
+   * never checkpointed, so the retry re-runs exactly the unit that landed), and
+   * a partial batch, reported as a failure and retried whole. Deterministic ids
+   * (JOB-RESTART-SAFETY P3) made those safe for the PROJECTIONS — the resource
+   * view and the graph both refuse a duplicate id — but a projection's guard
+   * says nothing about the log, which appends whatever it is handed. The result
+   * was a green graph over a doubled log: silent, and not undoable.
+   *
+   * So the batch is diffed against what the resource already holds. ONE view
+   * read per commit, never per annotation: the view for a 1,673-annotation
+   * resource is ~3 MB, and re-reading it per append would cost gigabytes of
+   * parsing for a single job.
    */
   async handleMarkCommit(event) {
     if (!event._userId) {
       throw new Error("mark:commit missing _userId (gateway injection)");
     }
     const annotations = event.annotations ?? [];
+    const rid = resourceId(event.resourceId);
     try {
-      let persisted = 0;
+      const view = await this.stores.eventStore.viewStorage.get(rid);
+      const present = new Set((view?.annotations.annotations ?? []).map((a) => String(a.id)));
       for (const annotation of annotations) {
+        if (present.has(String(annotation.id))) continue;
         await this.stores.eventStore.appendEvent({
           type: "mark:added",
-          resourceId: resourceId(event.resourceId),
+          resourceId: rid,
           userId: userId(event._userId),
           version: 1,
           payload: { annotation }
         });
-        persisted++;
+        present.add(String(annotation.id));
       }
       this.logger.debug("Committed annotation batch", {
         correlationId: event.correlationId,
         resourceId: event.resourceId,
-        persisted
+        persisted: annotations.length
       });
       this.eventBus.get("mark:commit-ok").next({
         correlationId: event.correlationId,
-        response: { persisted, annotationIds: annotations.map((a) => String(a.id)) }
+        // The DURABLE count, which is what the acknowledgement means ("every
+        // annotation named by the command is in the event log"). Not an append
+        // tally: a retry whose annotations are all already present has
+        // succeeded, and must be indistinguishable from the first commit or the
+        // caller would have to interpret a 0 that means "all good".
+        response: { persisted: annotations.length, annotationIds: annotations.map((a) => String(a.id)) }
       });
     } catch (error) {
       this.logger.error("Failed to commit annotation batch", {
@@ -10246,22 +10267,22 @@ var Stower = class {
           throw new Error(entityTypesNotRegisteredMessage(result.unknown));
         }
       }
-      for (const entityType of added) {
+      for (const entityType2 of added) {
         await this.stores.eventStore.appendEvent({
           type: "mark:entity-tag-added",
           resourceId: resourceId(event.resourceId),
           userId: uid,
           version: 1,
-          payload: { entityType }
+          payload: { entityType: entityType2 }
         });
       }
-      for (const entityType of removed) {
+      for (const entityType2 of removed) {
         await this.stores.eventStore.appendEvent({
           type: "mark:entity-tag-removed",
           resourceId: resourceId(event.resourceId),
           userId: uid,
           version: 1,
-          payload: { entityType }
+          payload: { entityType: entityType2 }
         });
       }
       this.eventBus.get("mark:update-entity-types-ok").next({ correlationId: event.correlationId });
@@ -10302,7 +10323,11 @@ var Stower = class {
         jobId: event.jobId,
         jobType: event.jobType,
         ...event.annotationId ? { annotationId: event.annotationId } : {},
-        result: event.result
+        result: event.result,
+        // How durability was ESTABLISHED (COMMIT-ACK-FALSE-FAILURE). An
+        // acknowledged batch and one inferred from a probe are different
+        // claims; absent means the question never arose.
+        ...event.durability !== void 0 ? { durability: event.durability } : {}
       }
     });
   }
@@ -10319,7 +10344,19 @@ var Stower = class {
         jobId: event.jobId,
         jobType: event.jobType,
         ...event.annotationId ? { annotationId: event.annotationId } : {},
-        error: event.error
+        error: event.error,
+        // The worker's JUDGMENTS, not just its message. Both are computed where
+        // the error is still typed and are unrecoverable here — the only other
+        // witness in the log is `error`, a flattened English string. Spread
+        // conditionally: absent `failureClass` means UNRECOGNISED, a different
+        // claim from 'transient', and defaulting either would write a judgment
+        // nobody made into a log nobody can rewrite.
+        ...event.failureClass !== void 0 ? { failureClass: event.failureClass } : {},
+        ...event.willRetry !== void 0 ? { willRetry: event.willRetry } : {},
+        // How durability was ESTABLISHED (COMMIT-ACK-FALSE-FAILURE). An
+        // acknowledged batch and one inferred from a probe are different
+        // claims; absent means the question never arose.
+        ...event.durability !== void 0 ? { durability: event.durability } : {}
       }
     });
   }
@@ -10336,8 +10373,8 @@ var import_operators2 = __toESM(require_operators());
 
 // src/smelt-progress.ts
 var SmeltProgressTimeout = class extends Error {
-  constructor(resourceId8, contentChecksum, timeoutMs) {
-    super(`smelt:settled not observed for ${resourceId8} (checksum ${contentChecksum.slice(0, 12)}\u2026) within ${timeoutMs}ms`);
+  constructor(resourceId10, contentChecksum, timeoutMs) {
+    super(`smelt:settled not observed for ${resourceId10} (checksum ${contentChecksum.slice(0, 12)}\u2026) within ${timeoutMs}ms`);
     this.name = "SmeltProgressTimeout";
   }
 };
@@ -10348,7 +10385,7 @@ function createSmeltProgress(eventBus) {
   const waiters = /* @__PURE__ */ new Set();
   let disposed = false;
   let lastSweep = Date.now();
-  const subscription = eventBus.get("smelt:settled").subscribe(({ resourceId: resourceId8, contentChecksum, outcome }) => {
+  const subscription = eventBus.get("smelt:settled").subscribe(({ resourceId: resourceId10, contentChecksum, outcome }) => {
     const now = Date.now();
     if (now - lastSweep >= SWEEP_INTERVAL_MS) {
       lastSweep = now;
@@ -10356,9 +10393,9 @@ function createSmeltProgress(eventBus) {
         if (now - entry.at >= SETTLED_TTL_MS) settled.delete(rid);
       }
     }
-    settled.set(resourceId8, { contentChecksum, outcome, at: now });
+    settled.set(resourceId10, { contentChecksum, outcome, at: now });
     for (const waiter of waiters) {
-      if (waiter.resourceId === resourceId8 && waiter.contentChecksum === contentChecksum) {
+      if (waiter.resourceId === resourceId10 && waiter.contentChecksum === contentChecksum) {
         clearTimeout(waiter.timer);
         waiters.delete(waiter);
         waiter.resolve(outcome);
@@ -10366,24 +10403,24 @@ function createSmeltProgress(eventBus) {
     }
   });
   return {
-    settledAt: (resourceId8) => {
-      const entry = settled.get(resourceId8);
+    settledAt: (resourceId10) => {
+      const entry = settled.get(resourceId10);
       return entry ? { contentChecksum: entry.contentChecksum, outcome: entry.outcome } : void 0;
     },
-    whenSettled: (resourceId8, contentChecksum, timeoutMs) => {
+    whenSettled: (resourceId10, contentChecksum, timeoutMs) => {
       if (disposed) return Promise.resolve("inert");
-      const current = settled.get(resourceId8);
+      const current = settled.get(resourceId10);
       if (current && current.contentChecksum === contentChecksum) {
         return Promise.resolve(current.outcome);
       }
       return new Promise((resolve2, reject) => {
         const waiter = {
-          resourceId: resourceId8,
+          resourceId: resourceId10,
           contentChecksum,
           resolve: resolve2,
           timer: setTimeout(() => {
             waiters.delete(waiter);
-            reject(new SmeltProgressTimeout(resourceId8, contentChecksum, timeoutMs));
+            reject(new SmeltProgressTimeout(resourceId10, contentChecksum, timeoutMs));
           }, timeoutMs)
         };
         waiters.add(waiter);
@@ -10405,14 +10442,14 @@ function createSmeltProgress(eventBus) {
 
 // src/read-anchored-text.ts
 var ANCHORED_TEXT_SETTLE_TIMEOUT_MS = 15e3;
-async function readAnchoredText(kb, resourceId8, settleTimeoutMs = ANCHORED_TEXT_SETTLE_TIMEOUT_MS) {
-  const view = await kb.views.get(resourceId(resourceId8));
+async function readAnchoredText(kb, resourceId10, settleTimeoutMs = ANCHORED_TEXT_SETTLE_TIMEOUT_MS) {
+  const view = await kb.views.get(resourceId(resourceId10));
   const checksum = getPrimaryRepresentation(view?.resource)?.checksum;
   if (!checksum) return { kind: "unknown" };
   const hit = await kb.anchoredText.read(checksum);
   if (hit) return hit;
   try {
-    const outcome = await kb.smeltProgress.whenSettled(resourceId8, checksum, settleTimeoutMs);
+    const outcome = await kb.smeltProgress.whenSettled(resourceId10, checksum, settleTimeoutMs);
     if (outcome === "skipped") return { kind: "no-map" };
     if (outcome === "inert") return { kind: "not-yet" };
     return await kb.anchoredText.read(checksum) ?? { kind: "not-yet" };
@@ -10469,11 +10506,11 @@ function representationSource(resource) {
     mediaType: primary.mediaType
   };
 }
-async function resolveRepresentation(deps, resourceId8) {
-  const view = await deps.views.get(resourceId8);
-  if (!view?.resource) throw new RepresentationMissing(String(resourceId8), "resource");
+async function resolveRepresentation(deps, resourceId10) {
+  const view = await deps.views.get(resourceId10);
+  if (!view?.resource) throw new RepresentationMissing(String(resourceId10), "resource");
   const source = representationSource(view.resource);
-  if (!source) throw new RepresentationMissing(String(resourceId8), "representation");
+  if (!source) throw new RepresentationMissing(String(resourceId10), "representation");
   return { stream: deps.content.retrieveStream(source.storageUri), mediaType: source.mediaType };
 }
 var SEMANTIC_OVER_FETCH = 4;
@@ -10481,8 +10518,8 @@ var ResourceContext = class _ResourceContext {
   /**
    * Get resource metadata from view storage
    */
-  static async getResourceMetadata(resourceId8, kb) {
-    const view = await kb.views.get(resourceId8);
+  static async getResourceMetadata(resourceId10, kb) {
+    const view = await kb.views.get(resourceId10);
     if (!view) {
       return null;
     }
@@ -10503,13 +10540,13 @@ var ResourceContext = class _ResourceContext {
    * where the graph is only eventually consistent.
    */
   static async listResources(filters, kb, semantic) {
-    const { search: rawSearch, archived, entityType, offset = 0, limit = 50 } = filters ?? {};
+    const { search: rawSearch, archived, entityType: entityType2, offset = 0, limit = 50 } = filters ?? {};
     const search = rawSearch?.trim() || void 0;
     if (search) {
       const lexical = await kb.graph.listResources({
         search,
         archived,
-        entityTypes: entityType ? [entityType] : void 0,
+        entityTypes: entityType2 ? [entityType2] : void 0,
         offset,
         limit
       });
@@ -10517,7 +10554,7 @@ var ResourceContext = class _ResourceContext {
       return _ResourceContext.semanticFallback(search, limit, kb, semantic);
     }
     const allViews = await kb.views.getAll();
-    const matches = allViews.map((view) => view.resource).filter((doc) => archived === void 0 || doc.archived === archived).filter((doc) => !entityType || getResourceEntityTypes(doc).includes(entityType)).sort(compareByRecencyThenId);
+    const matches = allViews.map((view) => view.resource).filter((doc) => archived === void 0 || doc.archived === archived).filter((doc) => !entityType2 || getResourceEntityTypes(doc).includes(entityType2)).sort(compareByRecencyThenId);
     return { resources: matches.slice(offset, offset + limit), total: matches.length, matchKind: "lexical" };
   }
   /**
@@ -10605,8 +10642,8 @@ var ResourceContext = class _ResourceContext {
 
 // src/weave-progress.ts
 var WeaveProgressTimeout = class extends Error {
-  constructor(resourceId8, sequenceNumber, timeoutMs) {
-    super(`weave:applied parity not reached for ${resourceId8} (seq ${sequenceNumber}) within ${timeoutMs}ms`);
+  constructor(resourceId10, sequenceNumber, timeoutMs) {
+    super(`weave:applied parity not reached for ${resourceId10} (seq ${sequenceNumber}) within ${timeoutMs}ms`);
     this.name = "WeaveProgressTimeout";
   }
 };
@@ -10630,19 +10667,19 @@ var GraphContext = class {
    *  - annotations on the resource → `annotation` nodes + `annotation-of` edges,
    *    so siblingEntityTypes = union of those nodes' entityTypes
    */
-  static async buildKnowledgeGraph(resourceId8, kb, logger2) {
-    let mainDoc = await kb.graph.getResource(resourceId8);
+  static async buildKnowledgeGraph(resourceId10, kb, logger2) {
+    let mainDoc = await kb.graph.getResource(resourceId10);
     if (!mainDoc) {
-      const view = await kb.views.get(resourceId8);
+      const view = await kb.views.get(resourceId10);
       if (view) {
         if (view.lastSequence !== void 0) {
           try {
             await kb.weaveProgress.whenApplied(
-              String(resourceId8),
+              String(resourceId10),
               view.lastSequence,
               PROJECTION_BARRIER_TIMEOUT_MS
             );
-            mainDoc = await kb.graph.getResource(resourceId8);
+            mainDoc = await kb.graph.getResource(resourceId10);
           } catch (error) {
             if (!(error instanceof WeaveProgressTimeout)) throw error;
           }
@@ -10650,19 +10687,19 @@ var GraphContext = class {
         if (!mainDoc) {
           for (const delayMs of PROJECTION_LAG_BACKOFF_MS) {
             await new Promise((resolve2) => setTimeout(resolve2, delayMs));
-            mainDoc = await kb.graph.getResource(resourceId8);
+            mainDoc = await kb.graph.getResource(resourceId10);
             if (mainDoc) break;
           }
         }
         if (!mainDoc) {
           recordGatherDegrade("graph");
           logger2?.warn("[gather DEGRADED] graph projection did not catch up \u2014 resource present in views, absent in graph", {
-            resourceId: String(resourceId8),
+            resourceId: String(resourceId10),
             lastSequence: view.lastSequence,
             barrierTimeoutMs: PROJECTION_BARRIER_TIMEOUT_MS
           });
           throw new Error(
-            `Graph projection did not catch up for ${String(resourceId8)} \u2014 present in views, absent in graph (Weaver lag, not a missing resource)`
+            `Graph projection did not catch up for ${String(resourceId10)} \u2014 present in views, absent in graph (Weaver lag, not a missing resource)`
           );
         }
       }
@@ -10670,11 +10707,11 @@ var GraphContext = class {
     if (!mainDoc) {
       throw new Error("Resource not found");
     }
-    const mainId = String(resourceId8);
+    const mainId = String(resourceId10);
     const [connections, referencedBy, annotations] = await Promise.all([
-      kb.graph.getResourceConnections(resourceId8),
-      kb.graph.getResourceReferencedBy(resourceId8),
-      kb.graph.getResourceAnnotations(resourceId8)
+      kb.graph.getResourceConnections(resourceId10),
+      kb.graph.getResourceReferencedBy(resourceId10),
+      kb.graph.getResourceAnnotations(resourceId10)
     ]);
     const nodes = [];
     const edges = [];
@@ -10694,7 +10731,7 @@ var GraphContext = class {
     const citedSeen = /* @__PURE__ */ new Set();
     for (const ann of referencedBy) {
       const source = getTargetSource(ann.target);
-      if (!source || source === String(resourceId8) || !ann.id || seen.has(ann.id)) continue;
+      if (!source || source === String(resourceId10) || !ann.id || seen.has(ann.id)) continue;
       if (!citedSeen.has(source)) {
         citedSeen.add(source);
         const view = await kb.views.get(resourceId(source));
@@ -10728,7 +10765,7 @@ var AnnotationContext = class {
    * @returns Rich context for LLM processing
    * @throws Error if annotation or resource not found
    */
-  static async buildLLMContext(annotationId4, resourceId8, kb, embeddingProvider, options = {}, inferenceClient, logger2) {
+  static async buildLLMContext(annotationId5, resourceId10, kb, embeddingProvider, options = {}, inferenceClient, logger2) {
     const {
       includeSourceContext = true,
       includeTargetContext = true,
@@ -10737,34 +10774,34 @@ var AnnotationContext = class {
     if (contextWindow < 100 || contextWindow > 5e3) {
       throw new Error("contextWindow must be between 100 and 5000");
     }
-    logger2?.debug("Building LLM context", { annotationId: annotationId4, resourceId: resourceId8 });
-    logger2?.debug("Getting view for resource", { resourceId: resourceId8 });
+    logger2?.debug("Building LLM context", { annotationId: annotationId5, resourceId: resourceId10 });
+    logger2?.debug("Getting view for resource", { resourceId: resourceId10 });
     let sourceView;
     try {
-      sourceView = await kb.views.get(resourceId8);
+      sourceView = await kb.views.get(resourceId10);
       logger2?.debug("Retrieved view", { hasView: !!sourceView });
       if (!sourceView) {
         throw new Error("Source resource not found");
       }
     } catch (error) {
-      logger2?.error("Error getting view", { resourceId: resourceId8, error });
+      logger2?.error("Error getting view", { resourceId: resourceId10, error });
       throw error;
     }
     logger2?.debug("Looking for annotation in resource", {
-      annotationId: annotationId4,
-      resourceId: resourceId8,
+      annotationId: annotationId5,
+      resourceId: resourceId10,
       totalAnnotations: sourceView.annotations.annotations.length,
       firstFiveIds: sourceView.annotations.annotations.slice(0, 5).map((a) => a.id)
     });
-    const annotation = sourceView.annotations.annotations.find((a) => a.id === annotationId4);
+    const annotation = sourceView.annotations.annotations.find((a) => a.id === annotationId5);
     logger2?.debug("Annotation search result", { found: !!annotation });
     if (!annotation) {
       throw new Error("Annotation not found in view");
     }
     const targetSource = getTargetSource(annotation.target);
-    logger2?.debug("Validating target resource", { targetSource, expectedResourceId: resourceId8 });
-    if (targetSource !== String(resourceId8)) {
-      throw new Error(`Annotation target resource ID (${targetSource}) does not match expected resource ID (${resourceId8})`);
+    logger2?.debug("Validating target resource", { targetSource, expectedResourceId: resourceId10 });
+    if (targetSource !== String(resourceId10)) {
+      throw new Error(`Annotation target resource ID (${targetSource}) does not match expected resource ID (${resourceId10})`);
     }
     const sourceDoc = sourceView.resource;
     const bodySource = getBodySource(annotation.body);
@@ -10780,7 +10817,7 @@ var AnnotationContext = class {
         throw new Error("Source content not found: no storageUri");
       }
       const primaryRep = getPrimaryRepresentation(sourceDoc);
-      const { data: sourceContent } = await kb.content.getBinary(resourceId8);
+      const { data: sourceContent } = await kb.content.getBinary(resourceId10);
       const contentStr = decodeRepresentation(Buffer.from(sourceContent), primaryRep?.mediaType ?? "text/plain");
       const targetSelectorRaw = getTargetSelector(annotation.target);
       const targetSelector = Array.isArray(targetSelectorRaw) ? targetSelectorRaw[0] : targetSelectorRaw;
@@ -10827,9 +10864,9 @@ var AnnotationContext = class {
         };
       }
     }
-    logger2?.debug("Building knowledge graph", { resourceId: resourceId8 });
-    const graph = await GraphContext.buildKnowledgeGraph(resourceId8, kb, logger2);
-    const views = deriveViews(graph, String(resourceId8), annotationId4);
+    logger2?.debug("Building knowledge graph", { resourceId: resourceId10 });
+    const graph = await GraphContext.buildKnowledgeGraph(resourceId10, kb, logger2);
+    const views = deriveViews(graph, String(resourceId10), annotationId5);
     const entityTypeStats = await kb.graph.getEntityTypeStats();
     const entityTypeFrequencies = {};
     for (const stat of entityTypeStats) {
@@ -10866,7 +10903,7 @@ Summary:`;
         const results = await kb.vectors.searchAnnotations(focalEmbedding, {
           limit: 10,
           scoreThreshold: 0.5,
-          filter: { excludeResourceId: resourceId8 }
+          filter: { excludeResourceId: resourceId10 }
         });
         const similar = [];
         for (const r of results) {
@@ -10919,10 +10956,10 @@ Summary:`;
    * Get resource annotations from view storage (fast path)
    * Throws if view missing
    */
-  static async getResourceAnnotations(resourceId8, kb) {
-    const view = await kb.views.get(resourceId8);
+  static async getResourceAnnotations(resourceId10, kb) {
+    const view = await kb.views.get(resourceId10);
     if (!view) {
-      throw new Error(`Resource ${resourceId8} not found in view storage`);
+      throw new Error(`Resource ${resourceId10} not found in view storage`);
     }
     return view.annotations;
   }
@@ -10930,8 +10967,8 @@ Summary:`;
    * Get all annotations
    * @returns Array of all annotation objects
    */
-  static async getAllAnnotations(resourceId8, kb) {
-    const annotations = await this.getResourceAnnotations(resourceId8, kb);
+  static async getAllAnnotations(resourceId10, kb) {
+    const annotations = await this.getResourceAnnotations(resourceId10, kb);
     return this.enrichResolvedReferences(annotations.annotations, kb);
   }
   /**
@@ -11000,8 +11037,8 @@ Summary:`;
    * Get resource stats (version info)
    * @returns Version and timestamp info for the annotations
    */
-  static async getResourceStats(resourceId8, kb) {
-    const annotations = await this.getResourceAnnotations(resourceId8, kb);
+  static async getResourceStats(resourceId10, kb) {
+    const annotations = await this.getResourceAnnotations(resourceId10, kb);
     return {
       resourceId: annotations.resourceId,
       version: annotations.version,
@@ -11011,16 +11048,16 @@ Summary:`;
   /**
    * Check if resource exists in view storage
    */
-  static async resourceExists(resourceId8, kb) {
-    return kb.views.exists(resourceId8);
+  static async resourceExists(resourceId10, kb) {
+    return kb.views.exists(resourceId10);
   }
   /**
    * Get a single annotation by ID
    * O(1) lookup using resource ID to access view storage
    */
-  static async getAnnotation(annotationId4, resourceId8, kb) {
-    const annotations = await this.getResourceAnnotations(resourceId8, kb);
-    return annotations.annotations.find((a) => a.id === annotationId4) || null;
+  static async getAnnotation(annotationId5, resourceId10, kb) {
+    const annotations = await this.getResourceAnnotations(resourceId10, kb);
+    return annotations.annotations.find((a) => a.id === annotationId5) || null;
   }
   /**
    * List annotations with optional filtering
@@ -11036,8 +11073,8 @@ Summary:`;
   /**
    * Get annotation context (selected text with surrounding context)
    */
-  static async getAnnotationContext(annotationId4, resourceId8, contextBefore, contextAfter, kb) {
-    const annotation = await this.getAnnotation(annotationId4, resourceId8, kb);
+  static async getAnnotationContext(annotationId5, resourceId10, contextBefore, contextAfter, kb) {
+    const annotation = await this.getAnnotation(annotationId5, resourceId10, kb);
     if (!annotation) {
       throw new Error("Annotation not found");
     }
@@ -11068,8 +11105,8 @@ Summary:`;
   /**
    * Generate AI summary of annotation in context
    */
-  static async generateAnnotationSummary(annotationId4, resourceId8, kb, inferenceClient) {
-    const annotation = await this.getAnnotation(annotationId4, resourceId8, kb);
+  static async generateAnnotationSummary(annotationId5, resourceId10, kb, inferenceClient) {
+    const annotation = await this.getAnnotation(annotationId5, resourceId10, kb);
     if (!annotation) {
       throw new Error("Annotation not found");
     }
@@ -11150,10 +11187,10 @@ Entity types: ${entityTypes.join(", ")}`;
     return inferenceClient.generateText(summaryPrompt, 500, 0.5);
   }
 };
-async function assembleResourceGraph(kb, resourceId8) {
+async function assembleResourceGraph(kb, resourceId10) {
   const eventQuery = new EventQuery(kb.eventStore.log.storage);
-  const events = await eventQuery.getResourceEvents(resourceId8);
-  const stored = await kb.eventStore.views.materializer.materialize(events, resourceId8);
+  const events = await eventQuery.getResourceEvents(resourceId10);
+  const stored = await kb.eventStore.views.materializer.materialize(events, resourceId10);
   if (!stored) return null;
   const annotations = stored.annotations.annotations;
   const entityReferences = annotations.filter((a) => {
@@ -11782,7 +11819,7 @@ var ResourceOperations = class {
   /**
    * Create a new resource via EventBus → Stower
    */
-  static async createResource(input, userId2, eventBus) {
+  static async createResource(input, userId3, eventBus) {
     const { resourceId: rId } = await busRequest(
       asBusRequestPrimitive(eventBus),
       "yield:create",
@@ -11792,7 +11829,7 @@ var ResourceOperations = class {
         contentChecksum: input.contentChecksum,
         byteSize: input.byteSize,
         format: input.format,
-        _userId: userId2,
+        _userId: userId3,
         language: input.language,
         entityTypes: input.entityTypes,
         generatedFrom: input.generatedFrom,
@@ -11812,7 +11849,7 @@ var ResourceOperations = class {
    * this only after the CloneTokenManager has validated the token — it is the
    * inner half of the flow, not a public entry point.
    */
-  static async persistClone(input, userId2, eventBus) {
+  static async persistClone(input, userId3, eventBus) {
     const { resourceId: rId } = await busRequest(
       asBusRequestPrimitive(eventBus),
       "yield:clone-persist",
@@ -11825,7 +11862,7 @@ var ResourceOperations = class {
         parentResourceId: input.parentResourceId,
         entityTypes: input.entityTypes,
         language: input.language,
-        _userId: userId2
+        _userId: userId3
       },
       3e4
     );
@@ -11837,7 +11874,7 @@ var ResourceOperations = class {
    * Archivist's register does the one `git add`, D4b); the command carries
    * storage coordinates only (EXTRACT-ARCHIVIST P3, D4a).
    */
-  static async createFromCloneToken(input, userId2, eventBus) {
+  static async createFromCloneToken(input, userId3, eventBus) {
     const { resourceId: rId } = await busRequest(
       asBusRequestPrimitive(eventBus),
       "yield:clone-create",
@@ -11849,7 +11886,7 @@ var ResourceOperations = class {
         byteSize: input.byteSize,
         format: input.format,
         archiveOriginal: input.archiveOriginal,
-        _userId: userId2
+        _userId: userId3
       },
       3e4
     );
@@ -12381,8 +12418,8 @@ function registerAnnotationContextHandler(eventBus, kb, parentLogger) {
 }
 function workingTreeContentReads(views, content) {
   return {
-    getBinary: async (resourceId8) => {
-      const { stream, mediaType } = await resolveRepresentation({ views, content }, resourceId8);
+    getBinary: async (resourceId10) => {
+      const { stream, mediaType } = await resolveRepresentation({ views, content }, resourceId10);
       const chunks = [];
       for await (const chunk of stream) chunks.push(chunk);
       const buf = Buffer.concat(chunks);
@@ -12404,12 +12441,12 @@ async function bootstrapEntityTypes(eventBus, eventStore, logger2) {
   }
   logger2?.info("Bootstrapping missing entity types", { missing: missing.length, existing: existingTypes.size });
   const SYSTEM_USER_ID = userId("00000000-0000-0000-0000-000000000000");
-  for (const entityType of missing) {
-    logger2?.debug("Adding entity type via EventBus", { entityType });
+  for (const entityType2 of missing) {
+    logger2?.debug("Adding entity type via EventBus", { entityType: entityType2 });
     await busRequest(
       asBusRequestPrimitive(eventBus),
       "frame:add-entity-type",
-      { tag: entityType, _userId: SYSTEM_USER_ID },
+      { tag: entityType2, _userId: SYSTEM_USER_ID },
       1e4
     );
   }
@@ -12429,19 +12466,25 @@ function eventAnnotationId(event) {
       return null;
   }
 }
-async function readAnnotationFromView(kb, resourceId8, annotationId4) {
-  const allAnnotations = await AnnotationContext.getAllAnnotations(resourceId8, kb);
-  return allAnnotations.find((a) => a.id === annotationId4) ?? null;
+async function readAnnotationFromView(kb, resourceId10, annotationId5) {
+  const allAnnotations = await AnnotationContext.getAllAnnotations(resourceId10, kb);
+  return allAnnotations.find((a) => a.id === annotationId5) ?? null;
 }
 function wireEnrichment(eventStore, kb) {
-  eventStore.setEnrichEvent(async (event, resourceId8) => {
+  eventStore.setEnrichEvent(async (event, resourceId10) => {
     const annId = eventAnnotationId(event);
     if (annId === null) return event;
-    const annotation = await readAnnotationFromView(kb, resourceId8, annId);
+    const annotation = await readAnnotationFromView(kb, resourceId10, annId);
     if (annotation === null) return event;
     return { ...event, annotation };
   });
 }
+
+// src/service.ts
+var STARTUP_CONNECT_TIMEOUT_MS = 6e4;
+var RESTART_HINT = "Exiting so the container restart policy can retry \u2014 it is normal for a dependency to be slow when every service restarts at once.";
+
+// src/archivist-main.ts
 var maybeRoot = process.env.SEMIONT_ROOT;
 if (!maybeRoot) {
   throw new Error("SEMIONT_ROOT environment variable is not set");
@@ -12511,17 +12554,8 @@ async function authenticate() {
 async function main() {
   const { initObservabilityNode } = await import('@semiont/observability/node');
   initObservabilityNode({ serviceName: "semiont-archivist" });
-  const { registerRestartCountProvider } = await import('@semiont/observability');
-  const supervisorEvents = "/semiont-state/archivist-supervisor/events.log";
-  registerRestartCountProvider(async () => {
-    try {
-      const { readFile } = await import('fs/promises');
-      const log = await readFile(supervisorEvents, "utf-8");
-      return Math.max(0, log.split("\n").filter((l) => l.includes("starting archivist")).length - 1);
-    } catch {
-      return 0;
-    }
-  });
+  const { registerSupervisorRestartCount } = await import('@semiont/observability/node');
+  registerSupervisorRestartCount();
   logger.info("Authenticating", { baseUrl });
   const tokenSubject = new import_rxjs6.BehaviorSubject(accessToken(await authenticate()));
   logger.info("Authenticated");
@@ -12550,18 +12584,34 @@ async function main() {
   const anchoredText = createAnchoredTextStore(anchoredTextDir, logger.child({ component: "anchored-text-store" }));
   const smeltProgress = createSmeltProgress(localBus);
   logger.info("Connecting to graph database", { type: graphConfig.type });
-  const graphDb = await getGraphDatabase(graphConfig);
+  const graphDb = await withDeadline(
+    "Graph database",
+    STARTUP_CONNECT_TIMEOUT_MS,
+    () => getGraphDatabase(graphConfig),
+    RESTART_HINT
+  );
   const embeddingConfig = config.services.embedding;
   logger.info("Connecting to embedding provider", { type: embeddingConfig.type, model: embeddingConfig.model });
-  const embeddingProvider = await createEmbeddingProvider(embeddingConfig);
+  const embeddingProvider = await withDeadline(
+    "Embedding provider",
+    STARTUP_CONNECT_TIMEOUT_MS,
+    () => createEmbeddingProvider(embeddingConfig),
+    RESTART_HINT
+  );
   const vectorsConfig = config.services.vectors;
   logger.info("Connecting to vector store", { type: vectorsConfig.type });
-  const vectorStore = await createVectorStore({
-    type: vectorsConfig.type,
-    host: vectorsConfig.host,
-    port: vectorsConfig.port,
-    dimensions: () => embeddingProvider.dimensions()
-  });
+  const vectorStore = await withDeadline(
+    "Vector store",
+    STARTUP_CONNECT_TIMEOUT_MS,
+    (signal) => createVectorStore({
+      signal,
+      type: vectorsConfig.type,
+      host: vectorsConfig.host,
+      port: vectorsConfig.port,
+      dimensions: () => embeddingProvider.dimensions()
+    }),
+    RESTART_HINT
+  );
   const stower = new Stower(
     { content, eventStore },
     localBus,