@semiont/make-meaning 0.5.11 → 0.5.12

package/README.md

@@ -20,7 +20,7 @@ Five **access actors** mediate every read and write — the bus-facing interface
 
 Two **projection pipelines** follow the event log to keep the eventually-consistent read models in sync — addressed by no one, replying to nothing:
 
-- **Graph Consumer** (project) — subscribes to graph-relevant domain events and projects them into the graph database; carried on the KB record (`kb.graphConsumer`) and rebuilt from the event log at startup (`rebuildAll()`)
+- **Weaver** (project) — subscribes to graph-relevant domain events and projects them into the graph database; carried on the KB record (`kb.weaver`) and rebuilt from the event log at startup (`rebuildAll()`)
 - **Smelter** (embed) — standalone embedding pipeline run via `@semiont/make-meaning/smelter-main` (not started by `startMakeMeaning`); subscribes to domain events, reads content from the KB working tree via `WorkerContentTransport`, chunks text, embeds via `@semiont/vectors`, and indexes into the vector store (Qdrant). On startup it reconciles Qdrant against the KS catalog — re-embedding what's missing or stale (every upsert is stamped with the embedded bytes' checksum, so changed content is detected) and deleting orphans — so a wiped Qdrant volume, or events missed while the worker was down, recover by restarting the smelter
 
 (The third derived read model — the materialized views — is not pipeline-maintained: the EventStore's `ViewManager` materializes views synchronously inside `appendEvent()` for a read-your-writes guarantee.)
@@ -60,7 +60,7 @@ await makeMeaning.stop();
 
 This single call initializes:
 - **KnowledgeSystem** — groups the Knowledge Base and its actors
-  - **KnowledgeBase** — groups EventStore, ViewStorage, WorkingTreeStore, GraphDatabase, GraphDBConsumer, and optionally VectorStore
+  - **KnowledgeBase** — groups EventStore, ViewStorage, WorkingTreeStore, GraphDatabase, Weaver, and optionally VectorStore
   - **Stower** — subscribes to write commands on EventBus
   - **Browser** — subscribes to all KB read queries and directory browse requests on EventBus
   - **Gatherer** — subscribes to annotation and resource gather requests on EventBus; searches vectors for semantically similar passages
@@ -113,7 +113,7 @@ graph TB
         GATHERER["Gatherer<br/>(context assembly)"]
         MATCHER["Matcher<br/>(search/link)"]
         SMELTER["Smelter<br/>(embed pipeline, standalone process)"]
-        GC["Graph Consumer<br/>(graph pipeline)"]
+        WEAVER["Weaver<br/>(graph pipeline)"]
         CTM["CloneTokenManager<br/>(clone)"]
         KB["Knowledge Base"]
         VECTORS["Vector Store<br/>(Qdrant)"]
@@ -125,7 +125,7 @@ graph TB
         MATCHER -->|search| VECTORS
         SMELTER -->|embed & index| VECTORS
         SMELTER -->|read| KB
-        GC -->|project| KB
+        WEAVER -->|project| KB
         CTM -->|query| KB
     end
 
@@ -134,7 +134,7 @@ graph TB
     BUS -->|"gather:requested<br/>gather:resource-requested"| GATHERER
     BUS -->|"match:search-requested"| MATCHER
     BUS -->|"domain events:<br/>yield:created, yield:updated<br/>yield:representation-added<br/>mark:added, mark:removed, mark:archived"| SMELTER
-    BUS -->|"graph-relevant<br/>domain events"| GC
+    BUS -->|"graph-relevant<br/>domain events"| WEAVER
     BUS -->|"yield:clone-token-requested<br/>yield:clone-resource-requested<br/>yield:clone-create"| CTM
 
     STOWER -->|"yield:create-ok, yield:update-ok, yield:move-ok<br/>mark:delete-ok, *-failed replies<br/>(domain events are republished onto the bus<br/>by the EventStore: yield:created, mark:added, ...)"| BUS
@@ -150,7 +150,7 @@ graph TB
 
     class BUS bus
     classDef vectorstore fill:#6b8e9d,stroke:#4a6a7a,stroke-width:2px,color:#fff
-    class STOWER,BROWSER,GATHERER,MATCHER,SMELTER,GC,CTM actor
+    class STOWER,BROWSER,GATHERER,MATCHER,SMELTER,WEAVER,CTM actor
     class KB kb
     class VECTORS vectorstore
     class Routes,Workers,EBC caller
@@ -168,7 +168,7 @@ The **Knowledge Base** is an inert store — it has no intelligence, no goals, n
 | **Materialized Views** | `ViewStorage` | Denormalized projections for fast reads (materialized synchronously on append) |
 | **Content Store** | `WorkingTreeStore` | Working-tree files addressed by URI |
 | **Graph** | `GraphDatabase` | Eventually consistent relationship projection |
-| **Graph Consumer** | `GraphDBConsumer` | Event-to-graph projection pipeline (one of the two pipeline actors; carried on the KB record because `createKnowledgeBase()` constructs and starts it) |
+| **Weaver** | `Weaver` | Event-to-graph projection pipeline (one of the two pipeline actors; carried on the KB record because `createKnowledgeBase()` constructs and starts it) |
 | **Vectors** *(optional)* | `VectorStore` | Semantic vector index (Qdrant + memory) via `@semiont/vectors` |
 
 Its sibling pipeline, the Smelter (event-to-vector projection), is **not** a KB member — it runs as a standalone process via `@semiont/make-meaning/smelter-main`.
@@ -177,7 +177,7 @@ Its sibling pipeline, the Smelter (event-to-vector projection), is **not** a KB
 import { createKnowledgeBase } from '@semiont/make-meaning';
 
 const kb = await createKnowledgeBase(eventStore, project, graphDb, eventBus, logger, options);
-// kb.eventStore, kb.views, kb.content, kb.graph, kb.graphConsumer
+// kb.eventStore, kb.views, kb.content, kb.graph, kb.weaver
 // kb.vectors (optional), kb.projectionsDir
 ```
 
@@ -221,7 +221,7 @@ This pattern (functional core, imperative shell) is shared with `@semiont/event-
 ### Knowledge Base
 
 - `createKnowledgeBase(eventStore, project, graphDb, eventBus, logger, options?)` — Async factory function
-- `KnowledgeBase` — Interface grouping the KB stores (`eventStore`, `views`, `content`, `graph`, optional `vectors`) plus the `graphConsumer` pipeline
+- `KnowledgeBase` — Interface grouping the KB stores (`eventStore`, `views`, `content`, `graph`, optional `vectors`) plus the `weaver` pipeline
 
 ### Actors
 
@@ -232,7 +232,7 @@ This pattern (functional core, imperative shell) is shared with `@semiont/event-
 - `CloneTokenManager` — Clone token lifecycle actor (yield domain)
 - `Smelter` / `createSmelterActorStateUnit` / `WorkerContentTransport` — the embedding pipeline, its domain-event fan-in, and the worker-side content transport; wired together by the standalone `@semiont/make-meaning/smelter-main` entry point, and exported for callers that run the pipeline on their own `WorkerBus`
 
-The Graph Consumer (`GraphDBConsumer`) is not exported — `createKnowledgeBase()` constructs it internally and exposes it as `kb.graphConsumer`.
+The Weaver is not exported — `createKnowledgeBase()` constructs it internally and exposes it as `kb.weaver`.
 
 ### Operations
 

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { JobQueue } from '@semiont/jobs';
 import { SemiontProject } from '@semiont/core/node';
-import { GraphServiceConfig, VectorsServiceConfig, EmbeddingServiceConfig, EventBus, Logger, StoredEvent, ResourceId, ResourceDescriptor, AnnotationId, components, ITransport, BaseUrl, ConnectionState, SemiontError, UserDID, EventMap, IContentTransport, PutBinaryRequest, PutBinaryOptions, AccessToken, StateUnit, BusRequestPrimitive, Annotation, UserId, GatheredContext, ResourceAnnotations, AnnotationCategory, GraphPath, GraphConnection } from '@semiont/core';
+import { GraphServiceConfig, VectorsServiceConfig, EmbeddingServiceConfig, StateUnit, EventBus, Logger, ResourceId, ResourceDescriptor, AnnotationId, components, ITransport, BaseUrl, ConnectionState, SemiontError, UserDID, EventMap, IContentTransport, PutBinaryRequest, PutBinaryOptions, AccessToken, BusRequestPrimitive, StoredEvent, Annotation, UserId, GatheredContext, ResourceAnnotations, AnnotationCategory, GraphPath, GraphConnection } from '@semiont/core';
 import { EventStore, ViewStorage } from '@semiont/event-sourcing';
 import { WorkingTreeStore } from '@semiont/content';
 import { GraphDatabase } from '@semiont/graph';
@@ -66,104 +66,79 @@ interface MakeMeaningConfig {
 }
 
 /**
- * GraphDB Consumer
- *
- * Subscribes to resource events and updates GraphDB accordingly.
- * Makes GraphDB a projection of Event Store events (single source of truth).
- *
- * Uses an RxJS pipeline with adaptive burst buffering:
- *   - First event after idle passes through immediately (zero latency)
- *   - Subsequent events in a burst are batched and flushed together
- *   - After idle, returns to passthrough mode
- *
- * Per-resource ordering is preserved via groupBy(resourceId) + concatMap.
- * Cross-resource parallelism is provided via mergeMap over groups.
- *
- * Burst buffer thresholds (see BATCH-GRAPH-CONSUMER-RX.md for tuning guidance):
- *   BURST_WINDOW_MS  = 50   — debounce window before flushing a batch
- *   MAX_BATCH_SIZE   = 500  — force flush to bound memory
- *   IDLE_TIMEOUT_MS  = 200  — silence before returning to passthrough
- *
- * ## Per-resource serialization
- *
- * `groupBy(resourceId) + concatMap(...)` is the stream-consumer flavor of
- * per-resource serialization — the same invariant enforced by `Smelter`,
- * `Gatherer`, and (in a different shape) `ViewManager`. See
- * `packages/core/src/serialize-per-key.ts` for the shared primitive used
- * by RPC-style services.
+ * WeaveProgress — backend-local fold of `weave:applied` signals
+ * (GRAPH-PROJECTION-SYNC P2, D2 = push).
+ *
+ * The Weaver emits `weave:applied` after applying an event (or a batch's
+ * last event) for a resource. This unit folds those signals into a
+ * per-resource applied-sequence map and exposes `whenApplied` — the
+ * applied-offset barrier: an event-driven await that resolves the moment
+ * the graph projection reaches parity with a known sequence (typically the
+ * view's `lastSequence`), and rejects with `WeaveProgressTimeout` on the
+ * bounded timeout so callers can fall back to the bounded-poll floor.
+ *
+ * Deliberately transport-blind: it subscribes to the channel, not to the
+ * Weaver. In-process the signal rides the core EventBus; after
+ * WEAVER-ISOLATION the same channel arrives through the bus gateway and
+ * this unit does not change.
+ *
+ * The map is ephemeral by design — on backend restart it rebuilds lazily
+ * from live signals. That loses nothing: a waiter only ever waits for an
+ * apply that has not happened yet, and those signals are still to come.
  */
 
-declare class GraphDBConsumer {
-    private eventStore;
-    private graphDb;
-    private coreEventBus;
-    private static readonly GRAPH_RELEVANT_EVENTS;
-    private static readonly BURST_WINDOW_MS;
-    private static readonly MAX_BATCH_SIZE;
-    private static readonly IDLE_TIMEOUT_MS;
-    private _globalSubscriptions;
-    private eventSubject;
-    private pipelineSubscription;
-    private lastProcessed;
-    private readonly logger;
-    constructor(eventStore: EventStore, graphDb: GraphDatabase, coreEventBus: EventBus, logger: Logger);
-    initialize(): Promise<void>;
-    /**
-     * Subscribe globally to ALL events, pre-filter to graph-relevant types,
-     * and wire through the RxJS burst-buffered pipeline.
-     */
-    private subscribeToGlobalEvents;
-    /**
-     * Wrap applyEventToGraph in try/catch so one failed event doesn't kill the pipeline.
-     */
-    private safeApplyEvent;
-    private ensureInitialized;
-    /**
-     * Stop the consumer, flush remaining buffered events, and unsubscribe.
-     */
-    stop(): Promise<void>;
-    /**
-     * Process a batch of events for the same resource.
-     * Partitions into consecutive same-type runs for batch optimization.
-     */
-    private processBatch;
-    /**
-     * Batch-optimized processing for consecutive events of the same type.
-     * Uses batch graph methods where available, falls back to sequential.
-     */
-    private applyBatchByType;
-    /**
-     * Build a ResourceDescriptor from a resource.created event.
-     * Extracted for reuse by both applyEventToGraph and applyBatchByType.
-     */
-    private buildResourceDescriptor;
-    /**
-     * Apply a single event to GraphDB.
-     */
-    protected applyEventToGraph(storedEvent: StoredEvent): Promise<void>;
-    /**
-     * Rebuild entire resource from events.
-     * Bypasses the live pipeline — reads directly from event store.
-     */
-    rebuildResource(resourceId: ResourceId): Promise<void>;
+interface WeaveProgress extends StateUnit {
+    /** Highest applied sequence seen for a resource, if any signal arrived. */
+    appliedUpTo(resourceId: string): number | undefined;
     /**
-     * Rebuild entire GraphDB from all events.
-     * Uses two-pass approach to ensure all resources exist before creating REFERENCES edges.
-     * Bypasses the live pipeline — reads directly from event store.
+     * Resolve when the Weaver has applied at least `sequenceNumber` for
+     * `resourceId` — immediately if the fold already covers it. Rejects with
+     * `WeaveProgressTimeout` after `timeoutMs`. After dispose it resolves
+     * immediately (inert): barrier callers degrade to their poll floor.
      */
-    rebuildAll(): Promise<void>;
-    /**
-     * Get consumer health metrics.
-     */
-    getHealthMetrics(): {
-        subscriptions: number;
-        lastProcessed: Record<string, number>;
-        pipelineActive: boolean;
-    };
+    whenApplied(resourceId: string, sequenceNumber: number, timeoutMs: number): Promise<void>;
+}
+
+/**
+ * SmeltProgress — backend-local fold of `smelt:settled` signals
+ * (SMELTER-INDEX-SYNC P1, D1 = push barrier).
+ *
+ * The Smelter emits `smelt:settled` after deciding a resource's content:
+ * `indexed` (embedded + upserted) or `skipped` (media gate, empty text) —
+ * keyed by the checksum of the bytes it inspected, and NEVER on transient
+ * failures (an error is not a decision; SMELTER-INDEX-SYNC A2). This unit
+ * folds those signals per resource and exposes `whenSettled` — the
+ * read-your-writes barrier: an event-driven await that resolves the moment
+ * the vector projection has settled the exact content generation the caller
+ * holds (the view's checksum), and rejects with `SmeltProgressTimeout` on
+ * the bounded timeout so callers degrade observably (L4 breadcrumb).
+ *
+ * Deliberately transport-blind: it subscribes to the channel, not to the
+ * Smelter. The signal arrives through the bus gateway from the standalone
+ * worker; an in-process Smelter would ride the core EventBus and this unit
+ * would not change (the WeaveProgress precedent).
+ *
+ * The fold is ephemeral by design — on backend restart it rebuilds lazily
+ * from live signals. Barrier callers probe the vector store first
+ * (SMELTER-INDEX-SYNC A3), so a cold fold only costs waits for resources
+ * whose settlement genuinely hasn't been observed yet.
+ */
+
+type SmeltOutcome = 'indexed' | 'skipped';
+interface SmeltProgress extends StateUnit {
+    /** The latest settlement seen for a resource, if any signal arrived. */
+    settledAt(resourceId: string): {
+        contentChecksum: string;
+        outcome: SmeltOutcome;
+    } | undefined;
     /**
-     * Shutdown consumer.
+     * Resolve with the Smelter's decision once it has settled `resourceId` at
+     * exactly `contentChecksum` — immediately if the fold already holds it.
+     * Rejects with `SmeltProgressTimeout` after `timeoutMs`. After dispose it
+     * resolves `'inert'`: shutdown must not throw through a gather in flight,
+     * and callers treat inert as breadcrumb-less degrade.
      */
-    shutdown(): Promise<void>;
+    whenSettled(resourceId: string, contentChecksum: string, timeoutMs: number): Promise<SmeltOutcome | 'inert'>;
 }
 
 /**
@@ -176,7 +151,10 @@ declare class GraphDBConsumer {
  * - Materialized Views (fast single-doc queries) — via ViewStorage
  * - Content Store (working-tree files, URI-addressed) — via WorkingTreeStore
  * - Graph (eventually consistent relationship projection) — via GraphDatabase
- * - Graph Consumer (event-to-graph projection) — via GraphDBConsumer
+ * - WeaveProgress (weave:applied fold — the graph-projection barrier; the
+ *   Weaver itself runs standalone via @semiont/make-meaning/weaver-main)
+ * - SmeltProgress (smelt:settled fold — the vector-projection barrier;
+ *   SMELTER-INDEX-SYNC, same standalone-actor arrangement as the Weaver)
  * - Vectors (semantic search) — via VectorStore (optional, read-only)
  *
  * The Smelter (event-to-vector projection) runs as an external actor
@@ -189,7 +167,8 @@ interface KnowledgeBase {
     views: ViewStorage;
     content: WorkingTreeStore;
     graph: GraphDatabase;
-    graphConsumer: GraphDBConsumer;
+    weaveProgress: WeaveProgress;
+    smeltProgress: SmeltProgress;
     vectors?: VectorStore;
     projectionsDir: string;
 }
@@ -288,7 +267,7 @@ declare class Stower {
  *
  * `groupBy(resourceId) + concatMap(...)` is the stream-consumer flavor of
  * per-resource serialization — the same invariant enforced by `Smelter`,
- * `GraphDBConsumer`, and (in a different shape) `ViewManager`. See
+ * `Weaver`, and (in a different shape) `ViewManager`. See
  * `packages/core/src/serialize-per-key.ts` for the shared primitive used
  * by RPC-style services.
  */
@@ -457,8 +436,10 @@ declare class CloneTokenManager {
  * - cloneTokenManager: token actor — manages resource clone tokens
  *
  * These are the five access actors. Two projection-pipeline actors complete
- * the seven: the Graph Consumer (kb.graphConsumer, started by
- * createKnowledgeBase) and the Smelter (standalone process via smelter-main).
+ * the seven, and BOTH run standalone (D4: the projections are part of their
+ * stores' stacks, not of the embedding process): the Weaver (weaver-main →
+ * graph) and the Smelter (smelter-main → vectors). The backend keeps only
+ * the Weaver's `weave:applied` fold (kb.weaveProgress).
  *
  * EventBus, JobQueue, and workers are peers to KnowledgeSystem, not members.
  */
@@ -611,6 +592,17 @@ declare class LocalContentTransport implements IContentTransport {
     dispose(): void;
 }
 
+/**
+ * Adapt a raw in-process `EventBus` to the `BusRequestPrimitive` that
+ * `busRequest` consumes. Lets backend-internal callers (bootstrap, event
+ * replay, linked-data import) use the same confirmed request/reply path as the
+ * SDK — `busRequest(asBusRequestPrimitive(eventBus), …)` — instead of
+ * hand-rolled `race(domain-event, *-failed, timeout)` blocks. The reply is
+ * matched by `correlationId`, so concurrent in-process writes can't cross-match
+ * (the latent bug in the old domain-event `race`).
+ */
+declare function asBusRequestPrimitive(eventBus: EventBus): BusRequestPrimitive;
+
 /**
  * Handles `mark:create-request` — the bus command for creating an annotation.
  *
@@ -713,7 +705,7 @@ declare function readEntityTypesProjection(project: SemiontProject): Promise<str
 /**
  * SmelterActorStateUnit — domain-event fan-in for the Smelter worker.
  *
- * Subscribes to the six smelter-relevant channels on a shared bus and
+ * Subscribes to the nine smelter-relevant channels on a shared bus and
  * exposes them as a single typed `events$` stream. Transport-neutral —
  * the caller passes a `WorkerBus` (HTTP `ActorStateUnit` today, an in-process
  * bus shim if/when one exists). The state unit does not own the bus and does
@@ -754,7 +746,7 @@ declare function createSmelterActorStateUnit(options: SmelterActorStateUnitOptio
  * Smelter processes events strictly in order per resourceId via
  * `groupBy(resourceId) + concatMap(...)`. This is the stream-consumer
  * flavor of per-resource serialization — the same invariant enforced by
- * `GraphDBConsumer`, `Gatherer`, and (in a different shape) `ViewManager`.
+ * `Weaver`, `Gatherer`, and (in a different shape) `ViewManager`.
  * See `packages/core/src/serialize-per-key.ts` for the shared primitive
  * used by RPC-style services.
  *
@@ -768,15 +760,18 @@ declare function createSmelterActorStateUnit(options: SmelterActorStateUnitOptio
  * Qdrant is an ephemeral projection of the event log. `reconcile()` brings
  * it back in sync at startup — after a wiped volume, or after events missed
  * while the worker was down. It is a planner: it diffs the store against the
- * catalog (over the `browse:*` RPC channels) — both membership AND content
- * freshness, via the checksum stamped onto every resource upsert — and
+ * catalog (over the `browse:*` RPC channels) — membership, content freshness
+ * (via the checksum stamped onto every resource upsert), and tag-stamp
+ * freshness (payload-only restamps; tag edits change no bytes) — and
  * enqueues `smelt:*` work items through the same mailbox as live events, so
- * per-resource ordering holds across the two paths (axioms S1/S2/S11/S12 in
- * `.plans/SMELTER-AXIOMS.md`).
+ * per-resource ordering holds across the two paths (axioms S1/S2/S11/S12/S13
+ * in `.plans/SMELTER-AXIOMS.md`).
  */
 
 interface ReconcileSummary {
     resourcesEmbedded: number;
+    /** Tag-only drift healed by payload restamps — never embedding calls (S13). */
+    resourcesRestamped: number;
     resourceVectorsDeleted: number;
     annotationsEmbedded: number;
     annotationVectorsDeleted: number;
@@ -809,7 +804,7 @@ interface SmelterTiming {
  * lanes and batch paths serve both kinds of input.
  */
 interface SmelterWorkItem {
-    type: 'smelt:embed' | 'smelt:purge' | 'smelt:embed-annotation' | 'smelt:purge-annotation';
+    type: 'smelt:embed' | 'smelt:restamp' | 'smelt:purge' | 'smelt:embed-annotation' | 'smelt:purge-annotation';
     resourceId: string;
     payload: Record<string, unknown>;
 }
@@ -852,6 +847,15 @@ declare class Smelter {
     /** Returns true if the input was processed without error. */
     private safeProcessEvent;
     private processEvent;
+    /**
+     * Payload-only stamp refresh: re-read the resource's CURRENT entity types
+     * (one code path — `resolveEntityTypes` — so any prior drift self-corrects
+     * on first touch) and rewrite the stamp on its existing points. Never calls
+     * the embedding provider (S13): content is unchanged by definition on every
+     * path that lands here. A resource with no points is a no-op — the stamp
+     * rides the next embed.
+     */
+    private restampResource;
     private handleResourcePurge;
     /**
      * Resolve a resource's embeddable text: bytes via the content transport,
@@ -862,6 +866,13 @@ declare class Smelter {
      * or is empty — callers skip it.
      */
     private fetchEmbeddableText;
+    /**
+     * The Smelter's single outbound signal (SMELTER-AXIOMS D3 as amended by
+     * SMELTER-INDEX-SYNC): a per-resource decision report for the barrier
+     * fold. Best-effort — waiters degrade to their bounded timeout; a signal
+     * failure must never fail the embed.
+     */
+    private emitSettled;
     /**
      * Read a resource's current entity types from the materialized view — the
      * authoritative source, updated before the EventBus fires to consumers — so
@@ -874,7 +885,15 @@ declare class Smelter {
     private resolveEntityTypes;
     private embedResource;
     private handleResourceArchived;
+    /**
+     * Restore what `handleResourceArchived` deleted, from CURRENT state: the
+     * resource's vectors (media-gated, full-replace) and its current exact-text
+     * annotations — the same catalog read `reconcile()` uses, so the live path
+     * and a restart agree (bugs/smelter-misses-unarchive.md).
+     */
+    private handleResourceUnarchived;
     private handleAnnotationAdded;
+    private indexAnnotation;
     private handleAnnotationRemoved;
     /**
      * Batch-embed chunks from multiple yield:created events in a single
@@ -1359,6 +1378,20 @@ declare class AnnotationContext {
 
 type KnowledgeGraph = components['schemas']['KnowledgeGraph'];
 declare class GraphContext {
+    /**
+     * Backoff schedule for the projection-lag grace in `buildKnowledgeGraph`
+     * (GRAPH-PROJECTION-SYNC P1). Total wait is bounded at 375 ms — the Weaver
+     * applies in tens of milliseconds when merely lagging; anything slower is
+     * treated as a real miss.
+     */
+    private static readonly PROJECTION_LAG_BACKOFF_MS;
+    /**
+     * Bounded wait for the applied-offset barrier (GRAPH-PROJECTION-SYNC P2).
+     * The Weaver applies in tens of milliseconds when merely lagging; a
+     * barrier that hasn't woken in 500 ms means signals have stalled and the
+     * poll floor above owns the remainder.
+     */
+    private static readonly PROJECTION_BARRIER_TIMEOUT_MS;
     /**
      * Get all resources referencing this resource (backlinks)
      * Requires graph traversal - must use graph database
@@ -1419,7 +1452,7 @@ declare class LLMContext {
      * Get comprehensive LLM context for a resource
      * Includes: main resource, related resources, annotations, graph, content, summary, references
      */
-    static getResourceContext(resourceId: ResourceId, options: LLMContextOptions, kb: KnowledgeBase, inferenceClient: InferenceClient): Promise<GatheredContext>;
+    static getResourceContext(resourceId: ResourceId, options: LLMContextOptions, kb: KnowledgeBase, inferenceClient: InferenceClient, logger: Logger): Promise<GatheredContext>;
 }
 
 /**
@@ -1442,5 +1475,5 @@ declare function generateResourceSummary(resourceName: string, content: string,
  */
 declare function generateReferenceSuggestions(referenceTitle: string, client: InferenceClient, entityType?: string, currentContent?: string): Promise<string[] | null>;
 
-export { AnnotationContext, AnnotationOperations, BACKUP_FORMAT, Browser, CloneTokenManager, FORMAT_VERSION, Gatherer$1 as Gatherer, GraphContext, LLMContext, LocalContentTransport, LocalTransport, Matcher, ResourceContext, ResourceOperations, Smelter, Stower, bootstrapEntityTypes, createKnowledgeBase, createSmelterActorStateUnit, exportBackup, exportLinkedData, generateReferenceSuggestions, generateResourceSummary, importBackup, importLinkedData, isBackupManifest, readEntityTypesProjection, registerAnnotationAssemblyHandler, registerAnnotationLookupHandlers, registerBindUpdateBodyHandler, registerBusHandlers, registerJobCommandHandlers, startMakeMeaning, stopKnowledgeSystem, validateManifestVersion };
+export { AnnotationContext, AnnotationOperations, BACKUP_FORMAT, Browser, CloneTokenManager, FORMAT_VERSION, Gatherer$1 as Gatherer, GraphContext, LLMContext, LocalContentTransport, LocalTransport, Matcher, ResourceContext, ResourceOperations, Smelter, Stower, asBusRequestPrimitive, bootstrapEntityTypes, createKnowledgeBase, createSmelterActorStateUnit, exportBackup, exportLinkedData, generateReferenceSuggestions, generateResourceSummary, importBackup, importLinkedData, isBackupManifest, readEntityTypesProjection, registerAnnotationAssemblyHandler, registerAnnotationLookupHandlers, registerBindUpdateBodyHandler, registerBusHandlers, registerJobCommandHandlers, startMakeMeaning, stopKnowledgeSystem, validateManifestVersion };
 export type { BackupContentReader, BackupEventStoreReader, BackupExporterOptions, BackupImportResult, BackupImporterOptions, BackupManifestHeader, BackupStreamSummary, BuildContextOptions, ContentBlobResolver, CreateAnnotationResult, CreateResourceInput, CreateResourceResult, KnowledgeBase, KnowledgeSystem, LLMContextOptions, LinkedDataContentReader, LinkedDataExporterOptions, LinkedDataImportResult, LinkedDataImporterOptions, LinkedDataViewReader, ListResourcesFilters, LocalTransportConfig, MakeMeaningConfig, MakeMeaningService, ReconcileState, ReconcileSummary, ReplayStats, SmelterActorStateUnit, SmelterActorStateUnitOptions, SmelterEvent, SmelterInput, SmelterTiming, SmelterWorkItem, UpdateAnnotationBodyResult };