@semiont/make-meaning 0.5.25 → 0.5.27

package/dist/index.js

@@ -1,11 +1,12 @@
 import { STALL_THRESHOLD_MS, FsJobQueue } from '@semiont/jobs';
 import { FilesystemViewStorage, resolveStorageUri, EventQuery, createEventStore } from '@semiont/event-sourcing';
-import { getResourceEntityTypes, getResourceId, getTargetSource, resourceId, getPrimaryRepresentation, decodeRepresentation, getBodySource, getTargetSelector, deriveViews, getTextPositionSelector, annotationId, errField, userId, generateUuid, getExactText, busRequest, cloneToken, baseMediaType, isSupportedMediaType, capabilitiesOf, didToAgent, assembleAnnotation, jobId, entityType, baseUrl, busLog, BRIDGED_CHANNELS, burstBuffer, textExtractionOf, chunkText, getPrimaryMediaType, extensionForMediaType, applyBodyOperations, softwareToAgent } from '@semiont/core';
+import { getResourceEntityTypes, getResourceId, getTargetSource, resourceId, getPrimaryRepresentation, decodeRepresentation, getBodySource, getTargetSelector, deriveViews, getTextPositionSelector, annotationId, errField, userId, generateUuid, getExactText, busRequest, cloneToken, baseMediaType, isSupportedMediaType, capabilitiesOf, didToAgent, assembleAnnotation, isGenerationJobParams, jobId, entityType, baseUrl, busLog, BRIDGED_CHANNELS, burstBuffer, textExtractionOf, chunkText, getPrimaryMediaType, extensionForMediaType, applyBodyOperations, softwareToAgent } from '@semiont/core';
 import { recordGatherDegrade, withActorSpan, recordBusEmit, withSpan, SpanKind, registerJobQueueProvider, registerVectorIndexSizeProvider } from '@semiont/observability';
 import { createInferenceClient } from '@semiont/inference';
-import { getGraphDatabase } from '@semiont/graph';
+import { compareByRecencyThenId, getGraphDatabase } from '@semiont/graph';
 import { WorkingTreeStore, createAnchoredTextStore, deriveStorageUri, anchoredTextStoreOverTransport, EXTRACTORS, calculateChecksum } from '@semiont/content';
 import { getEntityTypes, DEFAULT_ENTITY_TYPES } from '@semiont/ontology';
+import { mergeByResource } from '@semiont/vectors';
 import { promises } from 'fs';
 import * as path3 from 'path';
 import { createGzip, createGunzip } from 'zlib';
@@ -9905,11 +9906,9 @@ async function createKnowledgeBase(eventStore, project, graphDb, eventBus, logge
     graph: graphDb,
     weaveProgress,
     smeltProgress,
+    vectors: options.vectorStore,
     projectionsDir: project.projectionsDir
   };
-  if (options?.vectorStore) {
-    kb.vectors = options.vectorStore;
-  }
   return kb;
 }
 var PROJECTION_LAG_BACKOFF_MS = [25, 50, 100, 200];
@@ -9937,13 +9936,6 @@ var GraphContext = class {
   static async getResourceConnections(resourceId10, kb) {
     return kb.graph.getResourceConnections(resourceId10);
   }
-  /**
-   * Search resources by name (cross-resource query)
-   * Requires full-text search - must use graph database
-   */
-  static async searchResources(query, kb, limit) {
-    return kb.graph.searchResources(query, limit);
-  }
   /**
    * Build the unified knowledge graph for a resource's neighborhood:
    * resources AND annotations as typed nodes, typed/directional edges.
@@ -10064,6 +10056,18 @@ Format as a simple list, one suggestion per line.`;
   }
   return response.split("\n").map((line) => line.replace(/^[-*•]\s*/, "").trim()).filter((line) => line.length > 0).slice(0, 3);
 }
+
+// src/graph-read-grace.ts
+async function resourceWithViewGrace(kb, rid) {
+  const fromGraph = await kb.graph.getResource(rid).catch(() => null);
+  if (fromGraph) return { resource: fromGraph, laggedBehindView: false };
+  const view = await kb.views.get(rid);
+  if (view) return { resource: view.resource, laggedBehindView: true };
+  return { resource: null, laggedBehindView: false };
+}
+
+// src/resource-context.ts
+var SEMANTIC_OVER_FETCH = 4;
 var ResourceContext = class _ResourceContext {
   /**
    * Get resource metadata from view storage
@@ -10076,38 +10080,80 @@ var ResourceContext = class _ResourceContext {
     return view.resource;
   }
   /**
-   * List resources, optionally filtered.
+   * List resources, optionally filtered, as one page plus the size of the whole
+   * match set. Every filter is applied before pagination on both paths — a
+   * filter applied afterwards narrows the page rather than the match set, which
+   * is how a search scoped to an entity type can come back empty while hundreds
+   * of resources match.
    *
-   * When `search` is set, delegates to `kb.graph.searchResources`, which runs
-   * the name match in the graph engine instead of scanning every view in JS.
-   * The graph result is then narrowed by `archived` if requested.
+   * When `search` is set, the entire query — filtering, ordering and
+   * pagination — runs inside the graph engine.
    *
-   * When `search` is unset, falls back to scanning all materialized views.
-   * (TODO: also push the listing path through the graph for large KBs.)
+   * When `search` is unset, the materialized views answer instead. They are the
+   * barrier-stamped projection, so an unsearched listing is read-your-writes
+   * where the graph is only eventually consistent.
    */
-  static async listResources(filters, kb) {
-    if (filters?.search) {
-      const matches = await kb.graph.searchResources(filters.search);
-      const filtered = filters.archived !== void 0 ? matches.filter((doc) => doc.archived === filters.archived) : matches;
-      return _ResourceContext.sortByDateDesc(filtered);
+  static async listResources(filters, kb, semantic) {
+    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: entityType2 ? [entityType2] : void 0,
+        offset,
+        limit
+      });
+      if (lexical.total > 0 || offset > 0) return { ...lexical, matchKind: "lexical" };
+      return _ResourceContext.semanticFallback(search, limit, kb, semantic);
     }
     const allViews = await kb.views.getAll();
-    const resources = [];
-    for (const view of allViews) {
-      const doc = view.resource;
-      if (filters?.archived !== void 0 && doc.archived !== filters.archived) {
-        continue;
-      }
-      resources.push(doc);
-    }
-    return _ResourceContext.sortByDateDesc(resources);
+    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" };
   }
-  static sortByDateDesc(resources) {
-    return [...resources].sort((a, b) => {
-      const aTime = a.dateCreated ? new Date(a.dateCreated).getTime() : 0;
-      const bTime = b.dateCreated ? new Date(b.dateCreated).getTime() : 0;
-      return bTime - aTime;
-    });
+  /**
+   * Answer an empty lexical search from the vector index (SEMANTIC-FALLBACK):
+   * embed the query once, fold chunk hits per resource, floor them, and label
+   * the answer 'semantic' so the UI can say "no title matches, but these
+   * documents discuss it".
+   *
+   * Degradation is the contract (axioms S3–S5): unconfigured vectors, an
+   * absent provider, or ANY failure inside the fallback yields the same
+   * empty page the caller already had, labelled 'lexical' — a broken
+   * fallback must never turn a working empty search into an error.
+   *
+   * The floor is applied HERE rather than passed as `scoreThreshold`, so the
+   * below-floor hits exist to be counted — the debug line is the evidence
+   * decision #1's guessed 0.6 gets tuned from.
+   */
+  static async semanticFallback(search, limit, kb, semantic) {
+    const empty = { resources: [], total: 0, matchKind: "lexical" };
+    try {
+      const embedding = await semantic.embeddingProvider.embed(search);
+      const hits = await kb.vectors.searchResources(embedding, { limit: limit * SEMANTIC_OVER_FETCH });
+      const merged = mergeByResource(hits);
+      const aboveFloor = merged.filter((h) => h.score >= semantic.semanticFloor);
+      semantic.logger.debug("[search FALLBACK] semantic score distribution", {
+        chunkHits: hits.length,
+        resources: merged.length,
+        aboveFloor: aboveFloor.length,
+        belowFloor: merged.length - aboveFloor.length,
+        topScore: merged[0]?.score,
+        bottomScore: merged[merged.length - 1]?.score,
+        floor: semantic.semanticFloor
+      });
+      const resources = [];
+      for (const hit of aboveFloor.slice(0, limit)) {
+        const { resource } = await resourceWithViewGrace(kb, hit.resourceId);
+        if (resource) resources.push({ ...resource, content: hit.text });
+      }
+      return { resources, total: aboveFloor.length, matchKind: "semantic" };
+    } catch (error) {
+      semantic.logger.warn("[search FALLBACK] degraded to the empty lexical page", {
+        reason: error instanceof Error ? error.message : String(error)
+      });
+      return empty;
+    }
   }
   /**
    * Add content previews to resources (for search results)
@@ -10157,7 +10203,7 @@ var AnnotationContext = class {
    * @returns Rich context for LLM processing
    * @throws Error if annotation or resource not found
    */
-  static async buildLLMContext(annotationId5, resourceId10, kb, options = {}, inferenceClient, logger, embeddingProvider) {
+  static async buildLLMContext(annotationId5, resourceId10, kb, embeddingProvider, options = {}, inferenceClient, logger) {
     const {
       includeSourceContext = true,
       includeTargetContext = true,
@@ -10289,7 +10335,7 @@ Summary:`;
       }
     }
     let semanticContext;
-    if (kb.vectors && embeddingProvider && sourceContext?.selected) {
+    if (sourceContext?.selected) {
       try {
         const focalEmbedding = await embeddingProvider.embed(sourceContext.selected);
         const results = await kb.vectors.searchAnnotations(focalEmbedding, {
@@ -10613,46 +10659,44 @@ var LLMContext = class {
     if (options.includeContent) content.related = relatedContent;
     let semanticContext;
     const vectors = kb.vectors;
-    if (vectors) {
-      const excludeEntityTypes = options.excludeEntityTypes ?? [];
-      const search = () => vectors.searchByResource(resourceId10, {
-        limit: options.maxResources,
-        scoreThreshold: 0.5,
-        ...excludeEntityTypes.length ? { filter: { excludeEntityTypes } } : {}
-      });
-      let matches = await search();
-      if (matches.length === 0) {
-        const contentChecksum = getPrimaryRepresentation(mainDoc)?.checksum;
-        if (contentChecksum) {
-          try {
-            const outcome = await kb.smeltProgress.whenSettled(resourceIdStr, contentChecksum, settleTimeoutMs);
-            if (outcome === "indexed") {
-              matches = await search();
-            }
-          } catch (error) {
-            if (!(error instanceof SmeltProgressTimeout)) throw error;
-            recordGatherDegrade("vectors");
-            logger.warn("[gather DEGRADED] semanticContext absent \u2014 the vector projection did not settle within the barrier", {
-              resourceId: resourceIdStr,
-              contentChecksum,
-              timeoutMs: settleTimeoutMs
-            });
-          }
+    const excludeEntityTypes = options.excludeEntityTypes ?? [];
+    const search = () => vectors.searchByResource(resourceId10, {
+      limit: options.maxResources,
+      scoreThreshold: 0.5,
+      ...excludeEntityTypes.length ? { filter: { excludeEntityTypes } } : {}
+    });
+    let matches = await search();
+    if (matches.length === 0) {
+      const contentChecksum = getPrimaryRepresentation(mainDoc)?.checksum;
+      if (contentChecksum) {
+        try {
+          const outcome = await kb.smeltProgress.whenSettled(resourceIdStr, contentChecksum, settleTimeoutMs);
+          if (outcome === "indexed") {
+            matches = await search();
+          }
+        } catch (error) {
+          if (!(error instanceof SmeltProgressTimeout)) throw error;
+          recordGatherDegrade("vectors");
+          logger.warn("[gather DEGRADED] semanticContext absent \u2014 the vector projection did not settle within the barrier", {
+            resourceId: resourceIdStr,
+            contentChecksum,
+            timeoutMs: settleTimeoutMs
+          });
         }
       }
-      if (matches.length > 0) {
-        semanticContext = {
-          similar: matches.map((m) => ({
-            text: m.text,
-            resourceId: m.resourceId,
-            ...m.annotationId ? { annotationId: m.annotationId } : {},
-            score: m.score,
-            ...m.entityTypes ? { entityTypes: m.entityTypes } : {},
-            ...m.machineRead ? { machineRead: true } : {}
-          })),
-          ...excludeEntityTypes.length ? { excludedEntityTypes: excludeEntityTypes } : {}
-        };
-      }
+    }
+    if (matches.length > 0) {
+      semanticContext = {
+        similar: matches.map((m) => ({
+          text: m.text,
+          resourceId: m.resourceId,
+          ...m.annotationId ? { annotationId: m.annotationId } : {},
+          score: m.score,
+          ...m.entityTypes ? { entityTypes: m.entityTypes } : {},
+          ...m.machineRead ? { machineRead: true } : {}
+        })),
+        ...excludeEntityTypes.length ? { excludedEntityTypes: excludeEntityTypes } : {}
+      };
     }
     return {
       focus: {
@@ -10730,10 +10774,10 @@ var Gatherer = class {
         annotationId(event.annotationId),
         resourceId(event.resourceId),
         this.kb,
+        this.embeddingProvider,
         event.options ?? {},
         this.inferenceClient,
-        this.logger,
-        this.embeddingProvider
+        this.logger
       );
       this.eventBus.get("gather:complete").next({
         correlationId: event.correlationId,
@@ -10802,17 +10846,6 @@ var Gatherer = class {
 // src/matcher.ts
 var import_rxjs2 = __toESM(require_cjs());
 var import_operators2 = __toESM(require_operators());
-
-// src/graph-read-grace.ts
-async function resourceWithViewGrace(kb, rid) {
-  const fromGraph = await kb.graph.getResource(rid).catch(() => null);
-  if (fromGraph) return { resource: fromGraph, laggedBehindView: false };
-  const view = await kb.views.get(rid);
-  if (view) return { resource: view.resource, laggedBehindView: true };
-  return { resource: null, laggedBehindView: false };
-}
-
-// src/matcher.ts
 var Matcher = class {
   constructor(kb, eventBus, logger, inferenceClient, embeddingProvider) {
     this.kb = kb;
@@ -10885,7 +10918,7 @@ var Matcher = class {
    * Context-driven search: multi-source retrieval + composite scoring
    *
    * Retrieval sources:
-   * 1. Name match — graph.searchResources(searchTerm)
+   * 1. Name match — graph.listResources({ search: searchTerm })
    * 2. Entity type match — graph.listResources({ entityTypes })
    * 3. Graph neighborhood — connections from GatheredContext
    *
@@ -10901,7 +10934,7 @@ var Matcher = class {
     const views = deriveViews(context.graph, mainResourceId);
     const connections = views.connections;
     const [nameMatches, entityTypeMatches, semanticMatches] = await Promise.all([
-      this.kb.graph.searchResources(searchTerm),
+      this.kb.graph.listResources({ search: searchTerm, limit: 20 }).then((r) => r.resources),
       annotationEntityTypes.length > 0 ? this.kb.graph.listResources({ entityTypes: annotationEntityTypes, limit: 50 }).then((r) => r.resources) : Promise.resolve([]),
       // 4. Semantic match — vector similarity search (if vectors configured)
       this.searchVectors(searchTerm)
@@ -11127,7 +11160,7 @@ For each candidate, output a line with the number and score, like:
    * from the scorer.
    */
   async searchVectors(searchTerm) {
-    if (!this.kb.vectors || !this.embeddingProvider || !searchTerm.trim()) return [];
+    if (!searchTerm.trim()) return [];
     try {
       const embedding = await this.embeddingProvider.embed(searchTerm);
       const results = await this.kb.vectors.searchResources(embedding, {
@@ -11691,6 +11724,29 @@ var JOB_TYPES = [
   "tag-annotation",
   "generation"
 ];
+var inferencePairKey = (provider, model) => `${provider} ${model}`;
+function eachAdmittedInference(config, visit) {
+  for (const jobType of JOB_TYPES) {
+    try {
+      visit(resolveWorkerInference(config, jobType), jobType);
+    } catch {
+    }
+  }
+  for (const actor of ["gatherer", "matcher"]) {
+    try {
+      visit(resolveActorInference(config, actor));
+    } catch {
+    }
+  }
+}
+function deriveInferencePairs(config) {
+  const pairs = /* @__PURE__ */ new Map();
+  eachAdmittedInference(config, (inference) => {
+    const key = inferencePairKey(inference.type, inference.model);
+    if (!pairs.has(key)) pairs.set(key, inference);
+  });
+  return pairs;
+}
 function deriveAgentRoster(config) {
   const domain = config.site?.domain;
   if (!domain) {
@@ -11699,8 +11755,8 @@ function deriveAgentRoster(config) {
     );
   }
   const roster = /* @__PURE__ */ new Map();
-  const admit = (inference, jobType) => {
-    const key = `${inference.type}\0${inference.model}`;
+  eachAdmittedInference(config, (inference, jobType) => {
+    const key = inferencePairKey(inference.type, inference.model);
     let entry = roster.get(key);
     if (!entry) {
       entry = {
@@ -11710,19 +11766,7 @@ function deriveAgentRoster(config) {
       roster.set(key, entry);
     }
     if (jobType) entry.servesJobTypes.push(jobType);
-  };
-  for (const jobType of JOB_TYPES) {
-    try {
-      admit(resolveWorkerInference(config, jobType), jobType);
-    } catch {
-    }
-  }
-  for (const actor of ["gatherer", "matcher"]) {
-    try {
-      admit(resolveActorInference(config, actor));
-    } catch {
-    }
-  }
+  });
   return [...roster.values()].map(
     ({ agent, servesJobTypes }) => servesJobTypes.length ? { agent, servesJobTypes } : { agent }
   );
@@ -11730,12 +11774,14 @@ function deriveAgentRoster(config) {
 
 // src/browser.ts
 var Browser = class {
-  constructor(views, kb, eventBus, project, config, logger) {
+  constructor(views, kb, eventBus, project, config, limitsDiscovery, embeddingProvider, logger) {
     this.views = views;
     this.kb = kb;
     this.eventBus = eventBus;
     this.project = project;
     this.config = config;
+    this.limitsDiscovery = limitsDiscovery;
+    this.embeddingProvider = embeddingProvider;
     this.logger = logger;
   }
   views;
@@ -11743,6 +11789,8 @@ var Browser = class {
   eventBus;
   project;
   config;
+  limitsDiscovery;
+  embeddingProvider;
   subscriptions = [];
   logger;
   async initialize() {
@@ -11835,24 +11883,30 @@ var Browser = class {
   }
   async handleBrowseResources(event) {
     try {
-      let filteredDocs = await ResourceContext.listResources({
-        search: event.search,
-        archived: event.archived
-      }, this.kb);
-      if (event.entityType) {
-        filteredDocs = filteredDocs.filter((doc) => getResourceEntityTypes(doc).includes(event.entityType));
-      }
       const offset = event.offset ?? 0;
       const limit = event.limit ?? 50;
-      const paginatedDocs = filteredDocs.slice(offset, offset + limit);
-      const formattedDocs = event.search ? await ResourceContext.addContentPreviews(paginatedDocs, this.kb) : paginatedDocs;
+      const result = await ResourceContext.listResources({
+        search: event.search,
+        archived: event.archived,
+        entityType: event.entityType,
+        offset,
+        limit
+      }, this.kb, {
+        embeddingProvider: this.embeddingProvider,
+        semanticFloor: this.config.search.semanticFloor,
+        logger: this.logger
+      });
+      const formattedDocs = event.search && result.matchKind === "lexical" ? await ResourceContext.addContentPreviews(result.resources, this.kb) : result.resources;
       this.eventBus.get("browse:resources-result").next({
         correlationId: event.correlationId,
         response: {
           resources: formattedDocs,
-          total: filteredDocs.length,
+          total: result.total,
           offset,
-          limit
+          limit,
+          // The producer of the answer labels it (P1b moved the label here
+          // from a hardcoded 'lexical' when the fallback landed).
+          matchKind: result.matchKind
         }
       });
     } catch (error) {
@@ -12061,7 +12115,7 @@ var Browser = class {
   }
   async handleBrowseAgents(event) {
     try {
-      const agents = deriveAgentRoster(this.config);
+      const agents = await this.limitsDiscovery.enrich(deriveAgentRoster(this.config));
       this.eventBus.get("browse:agents-result").next({
         correlationId: event.correlationId,
         response: { agents }
@@ -12178,6 +12232,63 @@ var Browser = class {
     this.logger.info("Browser actor stopped");
   }
 };
+var LIMITS_ENRICH_BUDGET_MS = 1500;
+function createLimitsDiscovery(config, logger, options) {
+  const clientFactory = createInferenceClient;
+  const budgetMs = LIMITS_ENRICH_BUDGET_MS;
+  const clients = /* @__PURE__ */ new Map();
+  for (const [pair, inference] of deriveInferencePairs(config)) {
+    try {
+      clients.set(pair, clientFactory(inference, logger));
+    } catch (error) {
+      logger.debug("Limits discovery: client construction failed \u2014 pair enriches as absent", {
+        pair,
+        reason: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const consult = async (pair, client) => {
+    let timer2;
+    try {
+      const discovery = client.limits();
+      const raced = await Promise.race([
+        discovery,
+        new Promise((resolve2) => {
+          timer2 = setTimeout(() => resolve2(void 0), budgetMs);
+        })
+      ]);
+      if (raced === void 0) {
+        void discovery.catch(() => {
+        });
+        logger.debug("Limits discovery: consult exceeded budget \u2014 entry enriches as absent", { pair, budgetMs });
+        return void 0;
+      }
+      return { contextTokens: raced.contextTokens, maxOutputTokens: raced.maxOutputTokens };
+    } catch (error) {
+      logger.debug("Limits discovery: consult failed \u2014 entry enriches as absent", {
+        pair,
+        reason: error instanceof Error ? error.message : String(error)
+      });
+      return void 0;
+    } finally {
+      clearTimeout(timer2);
+    }
+  };
+  return {
+    async enrich(entries) {
+      const settled = await Promise.allSettled(entries.map(async (entry) => {
+        const agent = entry.agent;
+        if (agent["@type"] !== "Software" || !agent.provider || !agent.model) return entry;
+        const pair = inferencePairKey(agent.provider, agent.model);
+        const client = clients.get(pair);
+        if (!client) return entry;
+        const limits = await consult(pair, client);
+        return limits ? { ...entry, limits } : entry;
+      }));
+      return settled.map((s, i) => s.status === "fulfilled" ? s.value : entries[i]);
+    }
+  };
+}
 
 // src/event-enrichment.ts
 function eventAnnotationId(event) {
@@ -12207,7 +12318,7 @@ function asBusRequestPrimitive(eventBus) {
   return {
     emit(channel, payload) {
       eventBus.get(channel).next(payload);
-      return Promise.resolve();
+      return Promise.resolve(-1);
     },
     stream(channel) {
       return eventBus.get(channel).asObservable();
@@ -12656,6 +12767,38 @@ function registerJobCommandHandlers(eventBus, jobQueue, project, parentLogger) {
         throw new Error("_userId is required (injected by bus gateway)");
       }
       const user = parseDidUser(_userId);
+      let effectiveResourceId;
+      if (jobType === "generation") {
+        if (resId !== void 0) {
+          throw new Error(
+            "generation job:create must omit resourceId \u2014 the context's focus is authoritative"
+          );
+        }
+        const bag = params;
+        if (bag && bag.referenceId !== void 0) {
+          throw new Error(
+            "generation job:create must omit params.referenceId \u2014 the context's focus is authoritative"
+          );
+        }
+        if (!isGenerationJobParams(params)) {
+          throw new Error(
+            "generation params do not satisfy GenerationJobParams (title, storageUri, and context are required)"
+          );
+        }
+        const focus = params.context.focus;
+        const rid = focus?.kind === "resource" ? focus.resource?.["@id"] : focus?.kind === "annotation" ? focus.sourceResource?.["@id"] : void 0;
+        if (typeof rid !== "string" || rid.length === 0) {
+          throw new Error(
+            "generation context has no usable focus \u2014 pass a GatheredContext produced by gather.resource(...) or gather.annotation(...)"
+          );
+        }
+        effectiveResourceId = rid;
+      } else {
+        if (typeof resId !== "string" || resId.length === 0) {
+          throw new Error(`${jobType} job:create requires resourceId`);
+        }
+        effectiveResourceId = resId;
+      }
       const job = {
         status: "pending",
         metadata: {
@@ -12674,7 +12817,7 @@ function registerJobCommandHandlers(eventBus, jobQueue, project, parentLogger) {
           maxRetries: jobType === "generation" ? 0 : 1
         },
         params: {
-          resourceId: resourceId(resId),
+          resourceId: resourceId(effectiveResourceId),
           ...params
         }
       };
@@ -12880,35 +13023,40 @@ async function createKnowledgeSystemFromConfig(project, config, eventBus, logger
   logger.info("Connecting to graph database", { type: graphConfig.type });
   const graphDb = await withStartupTimeout("Graph database", getGraphDatabase(graphConfig));
   const eventStore = createEventStore(project, eventBus, logger.child({ component: "event-store" }));
-  let vectorStore;
-  let embeddingProvider;
   const vectorsConfig = config.services.vectors;
   const embeddingConfig = config.services.embedding;
-  if (vectorsConfig && embeddingConfig) {
-    const { createVectorStore, createEmbeddingProvider } = await import('@semiont/vectors');
-    logger.info("Connecting to embedding provider", { type: embeddingConfig.type, model: embeddingConfig.model });
-    embeddingProvider = await withStartupTimeout(
-      "Embedding provider",
-      createEmbeddingProvider(embeddingConfig)
-    );
-    logger.info("Connecting to vector store", { type: vectorsConfig.type ?? "qdrant" });
-    vectorStore = await withStartupTimeout(
-      "Vector store",
-      createVectorStore({
-        type: vectorsConfig.type ?? "qdrant",
-        host: vectorsConfig.host,
-        port: vectorsConfig.port,
-        dimensions: embeddingProvider.dimensions()
-      })
-    );
-    logger.info("Vector search initialized", {
-      store: vectorsConfig.type,
-      embedding: embeddingConfig.type,
-      model: embeddingConfig.model
-    });
-    const store = vectorStore;
-    registerVectorIndexSizeProvider(() => store.count());
+  const { createVectorStore, createEmbeddingProvider } = await import('@semiont/vectors');
+  logger.info("Connecting to embedding provider", { type: embeddingConfig.type, model: embeddingConfig.model });
+  const embeddingProvider = await withStartupTimeout(
+    "Embedding provider",
+    createEmbeddingProvider(embeddingConfig)
+  );
+  logger.info("Connecting to vector store", { type: vectorsConfig.type });
+  const vectorStore = await withStartupTimeout(
+    "Vector store",
+    createVectorStore({
+      type: vectorsConfig.type,
+      host: vectorsConfig.host,
+      port: vectorsConfig.port,
+      // Dimensionality is discovered from the provider, so it is passed as a
+      // thunk rather than probed here: the store calls it only if it needs it
+      // (Qdrant, and only to CREATE a collection). This matches how inference
+      // treats provider-derived facts — the client is built with no I/O and
+      // `limits()` are discovered at the point of use — instead of making a
+      // network round-trip a precondition of booting. A `memory` store, or a
+      // Qdrant whose collections already exist, never consults the provider.
+      dimensions: () => embeddingProvider.dimensions()
+    })
+  );
+  if (vectorsConfig.type === "memory") {
+    logger.info("memory vector store: the index rebuilds from the event log on every restart (reconcile re-embeds)");
   }
+  logger.info("Vector search initialized", {
+    store: vectorsConfig.type,
+    embedding: embeddingConfig.type,
+    model: embeddingConfig.model
+  });
+  registerVectorIndexSizeProvider(() => vectorStore.count());
   const kb = await createKnowledgeBase(eventStore, project, graphDb, eventBus, logger, {
     vectorStore,
     skipRebuild
@@ -12940,7 +13088,8 @@ async function createKnowledgeSystemFromConfig(project, config, eventBus, logger
     embeddingProvider
   );
   await matcher.initialize();
-  const browser = new Browser(kb.views, kb, eventBus, project, config, logger.child({ component: "browser" }));
+  const limitsDiscovery = createLimitsDiscovery(config, logger.child({ component: "limits-discovery" }));
+  const browser = new Browser(kb.views, kb, eventBus, project, config, limitsDiscovery, embeddingProvider, logger.child({ component: "browser" }));
   await browser.initialize();
   const cloneTokenManager = new CloneTokenManager(kb, eventBus, logger.child({ component: "clone-token-manager" }));
   await cloneTokenManager.initialize();
@@ -13023,6 +13172,7 @@ var LocalTransport = class {
         }
       }
     );
+    return -1;
   }
   on(channel, handler) {
     const sub = this.bus.get(channel).subscribe(handler);
@@ -14250,7 +14400,6 @@ async function replayEvent(event, eventBus, eventStore, resolveBlob, contentStor
       break;
     // Job events are transient — skip during replay
     case "job:started":
-    case "job:progress":
     case "job:completed":
     case "job:failed":
       logger?.debug("Skipping job event during replay", { type: event.type });