@equationalapplications/core-llm-wiki 7.0.0 → 7.1.0

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { __privateAdd, MetadataRepository, EmbeddingService, SearchService, JobManager, PromptService, IngestionService, MaintenanceService, ImportExportService, RetrievalService, WriteService, __privateGet, __privateSet, normalizeSourceRef, normalizeSourceHash, entitySummaryMetaKey, WikiSourceRefHashCollision, validateManifest, generateId, BaseRepository, emptyManifest, resolveNodeType, WikiStrictOntologyViolation, validateInlineEdges, resolveEdgeDefinitions, typeSatisfies, normalizeTitleKey, WikiTransactionError, extractSqliteCode } from './chunk-YNFYSLR6.mjs';
-export { DEFAULT_CHUNK_OVERLAP, DEFAULT_MAX_CHUNK_LENGTH, DEFAULT_MAX_EMBED_CHARS, EMBED_CHARS_CEILING, HEAL_ANCHORS_PER_CANDIDATE, HEAL_BATCH_SIZE, HEAL_MAX_FACT_BODY_CHARS_L3, HEAL_MAX_TASKS, HEAL_RECHECK_MS, HOOK_TIMEOUT_MARKER, ONTOLOGY_BACKFILL_BATCH_SIZE, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS, ONTOLOGY_BACKFILL_RECHECK_MS, ONTOLOGY_BACKFILL_SYSTEM_PROMPT, PromptService, PrunePartialFailureError, WikiBusyError, WikiDuplicateHashError, WikiIngestEmptyError, WikiInvalidReadOptions, WikiParseError, WikiSourceRefHashCollision, WikiStrictOntologyViolation, WikiTransactionError, chunkText, configureRandomSource, parseEmbedding, safeSlice, validateManifest } from './chunk-YNFYSLR6.mjs';
+import { __privateAdd, MetadataRepository, EmbeddingService, SearchService, JobManager, PromptService, IngestionService, MaintenanceService, ImportExportService, RetrievalService, WriteService, __privateGet, __privateSet, normalizeSourceRef, normalizeSourceHash, entitySummaryMetaKey, WikiSourceRefHashCollision, validateManifest, generateId, BaseRepository, emptyManifest, resolveNodeType, WikiStrictOntologyViolation, validateInlineEdges, resolveEdgeDefinitions, typeSatisfies, normalizeTitleKey, WikiTransactionError, extractSqliteCode } from './chunk-ZU7K6NAU.mjs';
+export { DEFAULT_CHUNK_OVERLAP, DEFAULT_MAX_CHUNK_LENGTH, DEFAULT_MAX_EMBED_CHARS, EMBED_CHARS_CEILING, HEAL_ANCHORS_PER_CANDIDATE, HEAL_BATCH_SIZE, HEAL_MAX_FACT_BODY_CHARS_L3, HEAL_MAX_TASKS, HEAL_RECHECK_MS, HOOK_TIMEOUT_MARKER, ONTOLOGY_BACKFILL_BATCH_SIZE, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS, ONTOLOGY_BACKFILL_RECHECK_MS, ONTOLOGY_BACKFILL_SYSTEM_PROMPT, PromptService, PrunePartialFailureError, WikiBusyError, WikiDuplicateHashError, WikiIngestEmptyError, WikiInvalidReadOptions, WikiParseError, WikiSourceRefHashCollision, WikiStrictOntologyViolation, WikiTransactionError, chunkText, configureRandomSource, parseEmbedding, safeSlice, validateManifest } from './chunk-ZU7K6NAU.mjs';
 import { appendRelatedSection, buildConceptDocument, buildLogMd, buildEntityIndexMd, buildRootIndexMd, isAllowedOkfPath, parseRootIndexMd, parseEntityIndexMd, parseConcept, splitRelatedSection, extractMarkdownLinks, parseLogMd, parseEventIdComment, latestVerified, formatSourcesJson, appendEventIdComment, parseVerifiedFlexible, parseCitationsList, deriveTrustTier, isStaleAfter } from '@equationalapplications/core-okf';
 
 // src/db/schema.ts

package/dist/{testing-BtsN1pTK.d.mts → testing-CA7723qk.d.mts}

@@ -1519,6 +1519,20 @@ declare class JobManager {
      */
     private readonly lockKeyFns;
     private _isReembedActive;
+    /**
+     * True while any reembed sweep is in flight — per-entity or global.
+     *
+     * Read-only; acquires nothing. Callers that mutate embedding failure
+     * markers across ALL entities (the dimension-promotion clear) must gate on
+     * this and defer, rather than resurrect rows an in-flight sweep already
+     * classified. See spec 2026-09-05-reembed-lock-scope-design.md §2.
+     *
+     * The global key `${prefix}:reembed` also ends in ':reembed', so the suffix
+     * scan alone would already match it. The explicit check is kept because it
+     * documents the intent and survives any future change to the global key's
+     * format.
+     */
+    isAnyReembedActive(): boolean;
     private _isImportActiveFor;
     private _isForgetActiveFor;
     private _isAnyMaintenanceActiveWithSuffix;
@@ -1534,8 +1548,10 @@ declare class JobManager {
      */
     isBlocked(operation: OperationType, entityId: string): boolean;
     /**
-     * Auto-heal historically only gated on the heal self-key. Keep that behavior
-     * for write() auto-trigger paths while preserving stricter checks in acquireLock().
+     * Auto-heal historically only gated on the heal self-key. Keep that
+     * permissiveness for write() auto-trigger paths — stricter checks stay in
+     * acquireLock() — with one exception: reembed sweeps, which are excluded
+     * structurally rather than by accident (see below).
      */
     tryAcquireAutoHealLock(entityId: string): boolean;
     /**
@@ -1636,6 +1652,19 @@ declare class EmbeddingService {
      * Revived rows are NOT embedded here. They become eligible and are picked up
      * by the NEXT sweep, because runReembed calls this after its candidates were
      * already classified; same-sweep revival would be re-entrant.
+     *
+     * Caller contract (spec 2026-09-05 §3.2): callers must not invoke this while
+     * a reembed sweep is in flight unless they hold that sweep's lock, because
+     * the marker clear spans every entity. `runReembed`'s tail call is exempt —
+     * by the tail, the sweep's classification phase is complete, so the clear
+     * cannot resurrect a row THIS sweep classified; any overlap with a
+     * concurrent import's entity-scoped, blob-guarded writes (an importDump of a
+     * different entity can run during a per-entity sweep) is bounded redundant
+     * work. External callers
+     * gate on `JobManager.isAnyReembedActive()` and defer. This service
+     * deliberately holds no `JobManager` reference: gating here instead of at
+     * the call site would make `runReembed`'s own tail call see its own lock and
+     * defer forever.
      */
     reconcileEmbeddingDimension(): Promise<void>;
     tryEmbedFact(fact: {
@@ -2026,6 +2055,15 @@ declare class MaintenanceService {
      * sets embedding_dimension_mismatch, so promotion never fires and markers
      * survive the swap. Use `runReembed({ force: true })` to clear that state —
      * `force` bypasses classification entirely and retries every row.
+     *
+     * Lock scope (spec 2026-09-05 §2): a marker mutation is legal while a sweep
+     * is in flight if and only if it cannot resurrect a row the sweep has
+     * classified. Mutations scoped to entities not under an active sweep key are
+     * legal — the entity-scoped ingest/import lock checks enforce that. The one
+     * mutation that spans every entity, `reconcileEmbeddingDimension`'s marker
+     * clear, is made legal by DEFERRING (importDump gates on
+     * `JobManager.isAnyReembedActive()`), never by widening a lock. Auto-heal is
+     * excluded from sweeps for the same reason.
      */
     runReembed(entityId?: string, opts?: {
         force?: boolean;

package/dist/{testing-BtsN1pTK.d.ts → testing-CA7723qk.d.ts}

@@ -1519,6 +1519,20 @@ declare class JobManager {
      */
     private readonly lockKeyFns;
     private _isReembedActive;
+    /**
+     * True while any reembed sweep is in flight — per-entity or global.
+     *
+     * Read-only; acquires nothing. Callers that mutate embedding failure
+     * markers across ALL entities (the dimension-promotion clear) must gate on
+     * this and defer, rather than resurrect rows an in-flight sweep already
+     * classified. See spec 2026-09-05-reembed-lock-scope-design.md §2.
+     *
+     * The global key `${prefix}:reembed` also ends in ':reembed', so the suffix
+     * scan alone would already match it. The explicit check is kept because it
+     * documents the intent and survives any future change to the global key's
+     * format.
+     */
+    isAnyReembedActive(): boolean;
     private _isImportActiveFor;
     private _isForgetActiveFor;
     private _isAnyMaintenanceActiveWithSuffix;
@@ -1534,8 +1548,10 @@ declare class JobManager {
      */
     isBlocked(operation: OperationType, entityId: string): boolean;
     /**
-     * Auto-heal historically only gated on the heal self-key. Keep that behavior
-     * for write() auto-trigger paths while preserving stricter checks in acquireLock().
+     * Auto-heal historically only gated on the heal self-key. Keep that
+     * permissiveness for write() auto-trigger paths — stricter checks stay in
+     * acquireLock() — with one exception: reembed sweeps, which are excluded
+     * structurally rather than by accident (see below).
      */
     tryAcquireAutoHealLock(entityId: string): boolean;
     /**
@@ -1636,6 +1652,19 @@ declare class EmbeddingService {
      * Revived rows are NOT embedded here. They become eligible and are picked up
      * by the NEXT sweep, because runReembed calls this after its candidates were
      * already classified; same-sweep revival would be re-entrant.
+     *
+     * Caller contract (spec 2026-09-05 §3.2): callers must not invoke this while
+     * a reembed sweep is in flight unless they hold that sweep's lock, because
+     * the marker clear spans every entity. `runReembed`'s tail call is exempt —
+     * by the tail, the sweep's classification phase is complete, so the clear
+     * cannot resurrect a row THIS sweep classified; any overlap with a
+     * concurrent import's entity-scoped, blob-guarded writes (an importDump of a
+     * different entity can run during a per-entity sweep) is bounded redundant
+     * work. External callers
+     * gate on `JobManager.isAnyReembedActive()` and defer. This service
+     * deliberately holds no `JobManager` reference: gating here instead of at
+     * the call site would make `runReembed`'s own tail call see its own lock and
+     * defer forever.
      */
     reconcileEmbeddingDimension(): Promise<void>;
     tryEmbedFact(fact: {
@@ -2026,6 +2055,15 @@ declare class MaintenanceService {
      * sets embedding_dimension_mismatch, so promotion never fires and markers
      * survive the swap. Use `runReembed({ force: true })` to clear that state —
      * `force` bypasses classification entirely and retries every row.
+     *
+     * Lock scope (spec 2026-09-05 §2): a marker mutation is legal while a sweep
+     * is in flight if and only if it cannot resurrect a row the sweep has
+     * classified. Mutations scoped to entities not under an active sweep key are
+     * legal — the entity-scoped ingest/import lock checks enforce that. The one
+     * mutation that spans every entity, `reconcileEmbeddingDimension`'s marker
+     * clear, is made legal by DEFERRING (importDump gates on
+     * `JobManager.isAnyReembedActive()`), never by widening a lock. Auto-heal is
+     * excluded from sweeps for the same reason.
      */
     runReembed(entityId?: string, opts?: {
         force?: boolean;

package/dist/testing.d.mts

@@ -1,3 +1,3 @@
-export { a8 as EmbeddingService, a9 as ImportExportService, aa as IngestionService, ab as JobManager, ab as JobManagerType, ac as MaintenanceService, ad as RetrievalService, ae as SearchService, ae as SearchServiceType, a1 as WikiMemoryTestAccess, af as WriteService } from './testing-BtsN1pTK.mjs';
+export { a8 as EmbeddingService, a9 as ImportExportService, aa as IngestionService, ab as JobManager, ab as JobManagerType, ac as MaintenanceService, ad as RetrievalService, ae as SearchService, ae as SearchServiceType, a1 as WikiMemoryTestAccess, af as WriteService } from './testing-CA7723qk.mjs';
 import '@equationalapplications/core-okf';
 import 'minisearch';

package/dist/testing.d.ts

@@ -1,3 +1,3 @@
-export { a8 as EmbeddingService, a9 as ImportExportService, aa as IngestionService, ab as JobManager, ab as JobManagerType, ac as MaintenanceService, ad as RetrievalService, ae as SearchService, ae as SearchServiceType, a1 as WikiMemoryTestAccess, af as WriteService } from './testing-BtsN1pTK.js';
+export { a8 as EmbeddingService, a9 as ImportExportService, aa as IngestionService, ab as JobManager, ab as JobManagerType, ac as MaintenanceService, ad as RetrievalService, ae as SearchService, ae as SearchServiceType, a1 as WikiMemoryTestAccess, af as WriteService } from './testing-CA7723qk.js';
 import '@equationalapplications/core-okf';
 import 'minisearch';

package/dist/testing.js

@@ -665,6 +665,19 @@ var EmbeddingService = class {
    * Revived rows are NOT embedded here. They become eligible and are picked up
    * by the NEXT sweep, because runReembed calls this after its candidates were
    * already classified; same-sweep revival would be re-entrant.
+   *
+   * Caller contract (spec 2026-09-05 §3.2): callers must not invoke this while
+   * a reembed sweep is in flight unless they hold that sweep's lock, because
+   * the marker clear spans every entity. `runReembed`'s tail call is exempt —
+   * by the tail, the sweep's classification phase is complete, so the clear
+   * cannot resurrect a row THIS sweep classified; any overlap with a
+   * concurrent import's entity-scoped, blob-guarded writes (an importDump of a
+   * different entity can run during a per-entity sweep) is bounded redundant
+   * work. External callers
+   * gate on `JobManager.isAnyReembedActive()` and defer. This service
+   * deliberately holds no `JobManager` reference: gating here instead of at
+   * the call site would make `runReembed`'s own tail call see its own lock and
+   * defer forever.
    */
   async reconcileEmbeddingDimension() {
     const mismatchValue = await this.metadataRepo.getMeta("embedding_dimension_mismatch");
@@ -1227,7 +1240,13 @@ var ImportExportService = class {
               this.db
             );
           }
-          await this.embeddingService.reconcileEmbeddingDimension();
+          if (this.jobManager.isAnyReembedActive()) {
+            console.info(
+              "[WikiMemory] importDump: embedding-dimension promotion deferred; a reembed sweep is in flight"
+            );
+          } else {
+            await this.embeddingService.reconcileEmbeddingDimension();
+          }
         } else {
           await this.metadataRepo.setMeta(
             "embedding_dimension_mismatch",
@@ -2319,6 +2338,15 @@ var MaintenanceService = class {
    * sets embedding_dimension_mismatch, so promotion never fires and markers
    * survive the swap. Use `runReembed({ force: true })` to clear that state —
    * `force` bypasses classification entirely and retries every row.
+   *
+   * Lock scope (spec 2026-09-05 §2): a marker mutation is legal while a sweep
+   * is in flight if and only if it cannot resurrect a row the sweep has
+   * classified. Mutations scoped to entities not under an active sweep key are
+   * legal — the entity-scoped ingest/import lock checks enforce that. The one
+   * mutation that spans every entity, `reconcileEmbeddingDimension`'s marker
+   * clear, is made legal by DEFERRING (importDump gates on
+   * `JobManager.isAnyReembedActive()`), never by widening a lock. Auto-heal is
+   * excluded from sweeps for the same reason.
    */
   async runReembed(entityId, opts) {
     const embedFn = this.options.llmProvider.embed;
@@ -4096,6 +4124,22 @@ var JobManager = class {
   _isReembedActive(entityId) {
     return this.activeMaintenanceJobs.has(this._reembedKey(entityId)) || this.activeMaintenanceJobs.has(this._globalReembedKey());
   }
+  /**
+   * True while any reembed sweep is in flight — per-entity or global.
+   *
+   * Read-only; acquires nothing. Callers that mutate embedding failure
+   * markers across ALL entities (the dimension-promotion clear) must gate on
+   * this and defer, rather than resurrect rows an in-flight sweep already
+   * classified. See spec 2026-09-05-reembed-lock-scope-design.md §2.
+   *
+   * The global key `${prefix}:reembed` also ends in ':reembed', so the suffix
+   * scan alone would already match it. The explicit check is kept because it
+   * documents the intent and survives any future change to the global key's
+   * format.
+   */
+  isAnyReembedActive() {
+    return this.activeMaintenanceJobs.has(this._globalReembedKey()) || this._isAnyMaintenanceActiveWithSuffix(":reembed");
+  }
   _isImportActiveFor(entityId) {
     return this.activeMaintenanceJobs.has(this._importKey(entityId)) || this.activeMaintenanceJobs.has(this._globalImportKey());
   }
@@ -4269,10 +4313,13 @@ var JobManager = class {
     }
   }
   /**
-   * Auto-heal historically only gated on the heal self-key. Keep that behavior
-   * for write() auto-trigger paths while preserving stricter checks in acquireLock().
+   * Auto-heal historically only gated on the heal self-key. Keep that
+   * permissiveness for write() auto-trigger paths — stricter checks stay in
+   * acquireLock() — with one exception: reembed sweeps, which are excluded
+   * structurally rather than by accident (see below).
    */
   tryAcquireAutoHealLock(entityId) {
+    if (this.isAnyReembedActive()) return false;
     const healKey = this._healKey(entityId);
     if (this.activeMaintenanceJobs.has(healKey)) return false;
     this.activeMaintenanceJobs.add(healKey);