@equationalapplications/core-llm-wiki 7.4.0 → 7.5.0

package/dist/{testing-Dmh1kfkd.d.mts → testing-ClpOUiLI.d.mts}

@@ -82,6 +82,14 @@ interface OntologyConfig {
         manifest: OntologyManifest;
         mode?: OntologyMode;
     }>;
+    /**
+     * Engine default for `runOntologyBackfill`'s `classifier` option.
+     * `'auto'` uses `llmProvider.classify` for node typing when present
+     * (no edges are proposed); `'llm'` always uses `generateText`. Default `'llm'`.
+     */
+    backfillClassifier?: 'auto' | 'llm';
+    /** Minimum classifier confidence to apply a node type. Finite, in [0, 1]. Default 0.5. */
+    classifyMinConfidence?: number;
 }
 interface ExtractedFactEdge {
     edge_type: string;
@@ -498,6 +506,8 @@ interface LLMProvider {
     /**
      * Generates text using the developer's LLM of choice.
      * Expected to return the raw text response (typically a JSON string).
+     * Called with the provider as `this`, so class-based adapters may keep
+     * SDK handles and config on the instance.
      */
     generateText: (params: {
         systemPrompt: string;
@@ -508,6 +518,8 @@ interface LLMProvider {
      * Must return a stable-dimension float array for any input text.
      * Called once per fact on creation/update, and once per `read()` query.
      * When absent or throws, `read()` falls back to MiniSearch.
+     * Called with the provider as `this` (never detached), same as
+     * `generateText`, so class-based adapters may read their own state.
      */
     embed?: (text: string) => Promise<number[]>;
     /**
@@ -521,6 +533,49 @@ interface LLMProvider {
      * never trusted as a guarantee.
      */
     maxOutputTokens?: number;
+    /**
+     * Optional non-generative classifier (System-One models such as Jev,
+     * OpenJev, or a local ONNX classifier). Core never calls it unless the host
+     * opts in (e.g. `WikiConfig.ontology.backfillClassifier: 'auto'`); merely
+     * providing it changes nothing (REQ-COMPAT-01.5). Output is validated as
+     * untrusted.
+     */
+    classify?: (request: ClassifyRequest) => Promise<ClassifyResponse>;
+}
+/** One typed question for a classifier. Vendor-neutral (Jev `noul` ↔ `binary`). */
+type ClassifierQuestion = {
+    kind: 'choice';
+    options: string[];
+    instructions?: string;
+} | {
+    kind: 'binary';
+    instructions: string;
+} | {
+    kind: 'score';
+    levels: string[];
+    instructions?: string;
+};
+/** One state evaluated against a map of questions (many questions per state, one state per call). */
+interface ClassifyRequest {
+    state: string;
+    questions: Record<string, ClassifierQuestion>;
+}
+type ClassifierAnswer = {
+    kind: 'choice';
+    choice: string;
+    confidence: number;
+    probabilities: Record<string, number>;
+} | {
+    kind: 'binary';
+    probability: number;
+} | {
+    kind: 'score';
+    score: number;
+    confidence: number;
+    probabilities: number[];
+};
+interface ClassifyResponse {
+    answers: Record<string, ClassifierAnswer>;
 }
 /**
  * Result of semantic ranking for a single fact.
@@ -2275,6 +2330,7 @@ declare class MaintenanceService {
     runOntologyBackfill(entityId: string, options?: {
         promptOverride?: string;
         batchSize?: number;
+        classifier?: 'auto' | 'llm';
     }): Promise<OntologyBackfillResult>;
     /**
      * Re-embed facts, honouring per-row failure markers and exponential backoff.
@@ -2349,7 +2405,15 @@ declare class MaintenanceService {
     doRunOntologyBackfill(entityId: string, options?: {
         promptOverride?: string;
         batchSize?: number;
+        classifier?: 'auto' | 'llm';
     }): Promise<OntologyBackfillResult>;
+    /**
+     * Classifier-mode backfill (spec §7.3): one `choice` question per untyped
+     * fact over the effective manifest's node-type slugs. Accepted answers go
+     * through `_applyOntologyBackfillBatch` exactly like LLM classifications.
+     * No edges are proposed.
+     */
+    private _runClassifierBackfill;
     /**
      * Applies one parsed backfill batch in its own transaction. Per-batch rather
      * than one transaction for the pass, so mergeEmergentUpdates semantics and
@@ -2657,6 +2721,7 @@ declare class WikiMemory {
     runOntologyBackfill(entityId: string, options?: {
         promptOverride?: string;
         batchSize?: number;
+        classifier?: 'auto' | 'llm';
     }): Promise<OntologyBackfillResult>;
     runReembed(entityId?: string, opts?: {
         force?: boolean;
@@ -2877,4 +2942,4 @@ declare class WikiMemory {
     setGeneratedByTask(taskId: string, entityId: string, actor: string): Promise<void>;
 }
 
-export { type WikiDiagnosticOperation as $, PrunePartialFailureError as A, type ReembedResult as B, type ChunkFailure as C, type DegradedRecord as D, type EmbedFactResult as E, type FormatContextOptions as F, type GraphNeighborhood as G, HEAL_BATCH_SIZE as H, type IngestDocumentResult as I, type VectorRankerFallback as J, type VectorRankerRankArgs as K, type LLMProvider as L, type MemoryBundle as M, type VectorRankerSemanticResult as N, ONTOLOGY_BACKFILL_BATCH_SIZE as O, type PromptOverrides as P, WikiBusyError as Q, type ReadOptions as R, type SQLiteAdapter as S, type WikiBusyOperation as T, type WikiCheckpoint as U, type VectorRanker as V, type WikiOptions as W, type WikiConfig as X, type WikiDiagnostic as Y, type WikiDiagnosticCode as Z, type WikiDiagnosticDetail as _, type MemoryDump as a, type WikiDiagnosticSeverity as a0, type WikiDiagnosticTrigger as a1, WikiDraftNotFound as a2, WikiDuplicateHashError as a3, type WikiEdge as a4, type WikiEvent as a5, type WikiFact as a6, WikiGraphNodeOwnershipConflict as a7, WikiIngestEmptyError as a8, WikiInvalidReadOptions as a9, type WikiMemoryTestAccess as aa, type WikiOutboxEvent as ab, WikiParseError as ac, WikiSourceRefHashCollision as ad, WikiStrictOntologyViolation as ae, type WikiTask as af, WikiTransactionError as ag, validateManifest as ah, EmbeddingService as ai, ImportExportService as aj, IngestionService as ak, JobManager as al, MaintenanceService as am, RetrievalService as an, SearchService as ao, WriteService as ap, type FormattedMemoryDump as b, WikiMemory as c, type DraftPage as d, type EmbedFailureKind as e, type EmbeddingMarkerKind as f, type EntityStatus as g, type ExtractedFact as h, type ExtractedFactEdge as i, type ExtractedFactWithOntology as j, type ExtractedTask as k, type GraphTraversalOptions as l, HEAL_RECHECK_MS as m, HOOK_TIMEOUT_MARKER as n, type HealResult as o, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS as p, ONTOLOGY_BACKFILL_RECHECK_MS as q, type OntologyBackfillResult as r, type OntologyConfig as s, type OntologyEdgeType as t, type OntologyManifest as u, type OntologyMode as v, type OntologyNodeType as w, type OntologyPromptContext as x, type OntologyUpdates as y, PromptService as z };
+export { type WikiConfig as $, type OntologyNodeType as A, type OntologyPromptContext as B, type ChunkFailure as C, type DegradedRecord as D, type EmbedFactResult as E, type FormatContextOptions as F, type GraphNeighborhood as G, HEAL_BATCH_SIZE as H, type IngestDocumentResult as I, type OntologyUpdates as J, PromptService as K, type LLMProvider as L, type MemoryBundle as M, PrunePartialFailureError as N, ONTOLOGY_BACKFILL_BATCH_SIZE as O, type PromptOverrides as P, type ReembedResult as Q, type ReadOptions as R, type SQLiteAdapter as S, type VectorRankerFallback as T, type VectorRankerRankArgs as U, type VectorRanker as V, type WikiOptions as W, type VectorRankerSemanticResult as X, WikiBusyError as Y, type WikiBusyOperation as Z, type WikiCheckpoint as _, type MemoryDump as a, type WikiDiagnostic as a0, type WikiDiagnosticCode as a1, type WikiDiagnosticDetail as a2, type WikiDiagnosticOperation as a3, type WikiDiagnosticSeverity as a4, type WikiDiagnosticTrigger as a5, WikiDraftNotFound as a6, WikiDuplicateHashError as a7, type WikiEdge as a8, type WikiEvent as a9, type WikiFact as aa, WikiGraphNodeOwnershipConflict as ab, WikiIngestEmptyError as ac, WikiInvalidReadOptions as ad, type WikiMemoryTestAccess as ae, type WikiOutboxEvent as af, WikiParseError as ag, WikiSourceRefHashCollision as ah, WikiStrictOntologyViolation as ai, type WikiTask as aj, WikiTransactionError as ak, validateManifest as al, EmbeddingService as am, ImportExportService as an, IngestionService as ao, JobManager as ap, MaintenanceService as aq, RetrievalService as ar, SearchService as as, WriteService as at, type FormattedMemoryDump as b, WikiMemory as c, type ClassifierAnswer as d, type ClassifierQuestion as e, type ClassifyRequest as f, type ClassifyResponse as g, type DraftPage as h, type EmbedFailureKind as i, type EmbeddingMarkerKind as j, type EntityStatus as k, type ExtractedFact as l, type ExtractedFactEdge as m, type ExtractedFactWithOntology as n, type ExtractedTask as o, type GraphTraversalOptions as p, HEAL_RECHECK_MS as q, HOOK_TIMEOUT_MARKER as r, type HealResult as s, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS as t, ONTOLOGY_BACKFILL_RECHECK_MS as u, type OntologyBackfillResult as v, type OntologyConfig as w, type OntologyEdgeType as x, type OntologyManifest as y, type OntologyMode as z };

package/dist/{testing-Dmh1kfkd.d.ts → testing-ClpOUiLI.d.ts}

@@ -82,6 +82,14 @@ interface OntologyConfig {
         manifest: OntologyManifest;
         mode?: OntologyMode;
     }>;
+    /**
+     * Engine default for `runOntologyBackfill`'s `classifier` option.
+     * `'auto'` uses `llmProvider.classify` for node typing when present
+     * (no edges are proposed); `'llm'` always uses `generateText`. Default `'llm'`.
+     */
+    backfillClassifier?: 'auto' | 'llm';
+    /** Minimum classifier confidence to apply a node type. Finite, in [0, 1]. Default 0.5. */
+    classifyMinConfidence?: number;
 }
 interface ExtractedFactEdge {
     edge_type: string;
@@ -498,6 +506,8 @@ interface LLMProvider {
     /**
      * Generates text using the developer's LLM of choice.
      * Expected to return the raw text response (typically a JSON string).
+     * Called with the provider as `this`, so class-based adapters may keep
+     * SDK handles and config on the instance.
      */
     generateText: (params: {
         systemPrompt: string;
@@ -508,6 +518,8 @@ interface LLMProvider {
      * Must return a stable-dimension float array for any input text.
      * Called once per fact on creation/update, and once per `read()` query.
      * When absent or throws, `read()` falls back to MiniSearch.
+     * Called with the provider as `this` (never detached), same as
+     * `generateText`, so class-based adapters may read their own state.
      */
     embed?: (text: string) => Promise<number[]>;
     /**
@@ -521,6 +533,49 @@ interface LLMProvider {
      * never trusted as a guarantee.
      */
     maxOutputTokens?: number;
+    /**
+     * Optional non-generative classifier (System-One models such as Jev,
+     * OpenJev, or a local ONNX classifier). Core never calls it unless the host
+     * opts in (e.g. `WikiConfig.ontology.backfillClassifier: 'auto'`); merely
+     * providing it changes nothing (REQ-COMPAT-01.5). Output is validated as
+     * untrusted.
+     */
+    classify?: (request: ClassifyRequest) => Promise<ClassifyResponse>;
+}
+/** One typed question for a classifier. Vendor-neutral (Jev `noul` ↔ `binary`). */
+type ClassifierQuestion = {
+    kind: 'choice';
+    options: string[];
+    instructions?: string;
+} | {
+    kind: 'binary';
+    instructions: string;
+} | {
+    kind: 'score';
+    levels: string[];
+    instructions?: string;
+};
+/** One state evaluated against a map of questions (many questions per state, one state per call). */
+interface ClassifyRequest {
+    state: string;
+    questions: Record<string, ClassifierQuestion>;
+}
+type ClassifierAnswer = {
+    kind: 'choice';
+    choice: string;
+    confidence: number;
+    probabilities: Record<string, number>;
+} | {
+    kind: 'binary';
+    probability: number;
+} | {
+    kind: 'score';
+    score: number;
+    confidence: number;
+    probabilities: number[];
+};
+interface ClassifyResponse {
+    answers: Record<string, ClassifierAnswer>;
 }
 /**
  * Result of semantic ranking for a single fact.
@@ -2275,6 +2330,7 @@ declare class MaintenanceService {
     runOntologyBackfill(entityId: string, options?: {
         promptOverride?: string;
         batchSize?: number;
+        classifier?: 'auto' | 'llm';
     }): Promise<OntologyBackfillResult>;
     /**
      * Re-embed facts, honouring per-row failure markers and exponential backoff.
@@ -2349,7 +2405,15 @@ declare class MaintenanceService {
     doRunOntologyBackfill(entityId: string, options?: {
         promptOverride?: string;
         batchSize?: number;
+        classifier?: 'auto' | 'llm';
     }): Promise<OntologyBackfillResult>;
+    /**
+     * Classifier-mode backfill (spec §7.3): one `choice` question per untyped
+     * fact over the effective manifest's node-type slugs. Accepted answers go
+     * through `_applyOntologyBackfillBatch` exactly like LLM classifications.
+     * No edges are proposed.
+     */
+    private _runClassifierBackfill;
     /**
      * Applies one parsed backfill batch in its own transaction. Per-batch rather
      * than one transaction for the pass, so mergeEmergentUpdates semantics and
@@ -2657,6 +2721,7 @@ declare class WikiMemory {
     runOntologyBackfill(entityId: string, options?: {
         promptOverride?: string;
         batchSize?: number;
+        classifier?: 'auto' | 'llm';
     }): Promise<OntologyBackfillResult>;
     runReembed(entityId?: string, opts?: {
         force?: boolean;
@@ -2877,4 +2942,4 @@ declare class WikiMemory {
     setGeneratedByTask(taskId: string, entityId: string, actor: string): Promise<void>;
 }
 
-export { type WikiDiagnosticOperation as $, PrunePartialFailureError as A, type ReembedResult as B, type ChunkFailure as C, type DegradedRecord as D, type EmbedFactResult as E, type FormatContextOptions as F, type GraphNeighborhood as G, HEAL_BATCH_SIZE as H, type IngestDocumentResult as I, type VectorRankerFallback as J, type VectorRankerRankArgs as K, type LLMProvider as L, type MemoryBundle as M, type VectorRankerSemanticResult as N, ONTOLOGY_BACKFILL_BATCH_SIZE as O, type PromptOverrides as P, WikiBusyError as Q, type ReadOptions as R, type SQLiteAdapter as S, type WikiBusyOperation as T, type WikiCheckpoint as U, type VectorRanker as V, type WikiOptions as W, type WikiConfig as X, type WikiDiagnostic as Y, type WikiDiagnosticCode as Z, type WikiDiagnosticDetail as _, type MemoryDump as a, type WikiDiagnosticSeverity as a0, type WikiDiagnosticTrigger as a1, WikiDraftNotFound as a2, WikiDuplicateHashError as a3, type WikiEdge as a4, type WikiEvent as a5, type WikiFact as a6, WikiGraphNodeOwnershipConflict as a7, WikiIngestEmptyError as a8, WikiInvalidReadOptions as a9, type WikiMemoryTestAccess as aa, type WikiOutboxEvent as ab, WikiParseError as ac, WikiSourceRefHashCollision as ad, WikiStrictOntologyViolation as ae, type WikiTask as af, WikiTransactionError as ag, validateManifest as ah, EmbeddingService as ai, ImportExportService as aj, IngestionService as ak, JobManager as al, MaintenanceService as am, RetrievalService as an, SearchService as ao, WriteService as ap, type FormattedMemoryDump as b, WikiMemory as c, type DraftPage as d, type EmbedFailureKind as e, type EmbeddingMarkerKind as f, type EntityStatus as g, type ExtractedFact as h, type ExtractedFactEdge as i, type ExtractedFactWithOntology as j, type ExtractedTask as k, type GraphTraversalOptions as l, HEAL_RECHECK_MS as m, HOOK_TIMEOUT_MARKER as n, type HealResult as o, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS as p, ONTOLOGY_BACKFILL_RECHECK_MS as q, type OntologyBackfillResult as r, type OntologyConfig as s, type OntologyEdgeType as t, type OntologyManifest as u, type OntologyMode as v, type OntologyNodeType as w, type OntologyPromptContext as x, type OntologyUpdates as y, PromptService as z };
+export { type WikiConfig as $, type OntologyNodeType as A, type OntologyPromptContext as B, type ChunkFailure as C, type DegradedRecord as D, type EmbedFactResult as E, type FormatContextOptions as F, type GraphNeighborhood as G, HEAL_BATCH_SIZE as H, type IngestDocumentResult as I, type OntologyUpdates as J, PromptService as K, type LLMProvider as L, type MemoryBundle as M, PrunePartialFailureError as N, ONTOLOGY_BACKFILL_BATCH_SIZE as O, type PromptOverrides as P, type ReembedResult as Q, type ReadOptions as R, type SQLiteAdapter as S, type VectorRankerFallback as T, type VectorRankerRankArgs as U, type VectorRanker as V, type WikiOptions as W, type VectorRankerSemanticResult as X, WikiBusyError as Y, type WikiBusyOperation as Z, type WikiCheckpoint as _, type MemoryDump as a, type WikiDiagnostic as a0, type WikiDiagnosticCode as a1, type WikiDiagnosticDetail as a2, type WikiDiagnosticOperation as a3, type WikiDiagnosticSeverity as a4, type WikiDiagnosticTrigger as a5, WikiDraftNotFound as a6, WikiDuplicateHashError as a7, type WikiEdge as a8, type WikiEvent as a9, type WikiFact as aa, WikiGraphNodeOwnershipConflict as ab, WikiIngestEmptyError as ac, WikiInvalidReadOptions as ad, type WikiMemoryTestAccess as ae, type WikiOutboxEvent as af, WikiParseError as ag, WikiSourceRefHashCollision as ah, WikiStrictOntologyViolation as ai, type WikiTask as aj, WikiTransactionError as ak, validateManifest as al, EmbeddingService as am, ImportExportService as an, IngestionService as ao, JobManager as ap, MaintenanceService as aq, RetrievalService as ar, SearchService as as, WriteService as at, type FormattedMemoryDump as b, WikiMemory as c, type ClassifierAnswer as d, type ClassifierQuestion as e, type ClassifyRequest as f, type ClassifyResponse as g, type DraftPage as h, type EmbedFailureKind as i, type EmbeddingMarkerKind as j, type EntityStatus as k, type ExtractedFact as l, type ExtractedFactEdge as m, type ExtractedFactWithOntology as n, type ExtractedTask as o, type GraphTraversalOptions as p, HEAL_RECHECK_MS as q, HOOK_TIMEOUT_MARKER as r, type HealResult as s, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS as t, ONTOLOGY_BACKFILL_RECHECK_MS as u, type OntologyBackfillResult as v, type OntologyConfig as w, type OntologyEdgeType as x, type OntologyManifest as y, type OntologyMode as z };

package/dist/testing.d.mts

@@ -1,3 +1,3 @@
-export { ai as EmbeddingService, aj as ImportExportService, ak as IngestionService, al as JobManager, al as JobManagerType, am as MaintenanceService, an as RetrievalService, ao as SearchService, ao as SearchServiceType, aa as WikiMemoryTestAccess, ap as WriteService } from './testing-Dmh1kfkd.mjs';
+export { am as EmbeddingService, an as ImportExportService, ao as IngestionService, ap as JobManager, ap as JobManagerType, aq as MaintenanceService, ar as RetrievalService, as as SearchService, as as SearchServiceType, ae as WikiMemoryTestAccess, at as WriteService } from './testing-ClpOUiLI.mjs';
 import '@equationalapplications/core-okf';
 import 'minisearch';

package/dist/testing.d.ts

@@ -1,3 +1,3 @@
-export { ai as EmbeddingService, aj as ImportExportService, ak as IngestionService, al as JobManager, al as JobManagerType, am as MaintenanceService, an as RetrievalService, ao as SearchService, ao as SearchServiceType, aa as WikiMemoryTestAccess, ap as WriteService } from './testing-Dmh1kfkd.js';
+export { am as EmbeddingService, an as ImportExportService, ao as IngestionService, ap as JobManager, ap as JobManagerType, aq as MaintenanceService, ar as RetrievalService, as as SearchService, as as SearchServiceType, ae as WikiMemoryTestAccess, at as WriteService } from './testing-ClpOUiLI.js';
 import '@equationalapplications/core-okf';
 import 'minisearch';

package/dist/testing.js

@@ -817,8 +817,7 @@ var EmbeddingService = class {
     }
   }
   async tryEmbedFact(fact, ctx) {
-    const embedFn = this.options.llmProvider.embed;
-    if (typeof embedFn !== "function") return { ok: false, kind: "no_provider" };
+    if (typeof this.options.llmProvider.embed !== "function") return { ok: false, kind: "no_provider" };
     let tagsStr;
     if (Array.isArray(fact.tags)) {
       tagsStr = fact.tags.join(" ");
@@ -835,7 +834,7 @@ var EmbeddingService = class {
     const text = clip(`${fact.title} ${fact.body} ${tagsStr}`.trim(), maxEmbedChars);
     let float32Vector;
     try {
-      const vector = await embedFn(text);
+      const vector = await this.options.llmProvider.embed(text);
       if (vector.length === 0 || !vector.every((v) => typeof v === "number" && isFinite(v))) {
         console.warn(`[WikiMemory] embedFact: embed() returned an invalid vector for ${fact.id}; skipping.`);
         this.reportEmbed(ctx, fact, "embedding_failed", "invalid_vector");
@@ -2281,6 +2280,51 @@ var IngestionService = class {
   }
 };
 
+// src/utils/classifier.ts
+var isUnit = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= 1;
+function validateClassifierAnswer(response, key, question) {
+  try {
+    if (response === null || typeof response !== "object") return { ok: false, reason: "malformed" };
+    const answers = response.answers;
+    if (answers === null || typeof answers !== "object") return { ok: false, reason: "missing_answer" };
+    if (!Object.prototype.hasOwnProperty.call(answers, key)) return { ok: false, reason: "missing_answer" };
+    const raw = answers[key];
+    if (raw === null || typeof raw !== "object") return { ok: false, reason: "missing_answer" };
+    const a = raw;
+    if (a.kind !== question.kind) return { ok: false, reason: "kind_mismatch" };
+    if (question.kind === "choice") {
+      if (typeof a.choice !== "string" || !question.options.includes(a.choice)) return { ok: false, reason: "choice_not_offered" };
+      if (!isUnit(a.confidence)) return { ok: false, reason: "invalid_probability" };
+      const probs = a.probabilities;
+      if (probs === null || typeof probs !== "object" || Array.isArray(probs)) return { ok: false, reason: "invalid_probability" };
+      const probabilities = {};
+      for (const [k, v] of Object.entries(probs)) {
+        if (!isUnit(v)) return { ok: false, reason: "invalid_probability" };
+        probabilities[k] = v;
+      }
+      return { ok: true, answer: { kind: "choice", choice: a.choice, confidence: a.confidence, probabilities } };
+    }
+    if (question.kind === "binary") {
+      if (!isUnit(a.probability)) return { ok: false, reason: "invalid_probability" };
+      return { ok: true, answer: { kind: "binary", probability: a.probability } };
+    }
+    const maxScore = question.levels.length - 1;
+    if (typeof a.score !== "number" || !Number.isFinite(a.score) || a.score < 0 || a.score > maxScore) {
+      return { ok: false, reason: "score_out_of_range" };
+    }
+    if (!isUnit(a.confidence)) return { ok: false, reason: "invalid_probability" };
+    if (!Array.isArray(a.probabilities) || !a.probabilities.every(isUnit)) return { ok: false, reason: "invalid_probability" };
+    return { ok: true, answer: { kind: "score", score: a.score, confidence: a.confidence, probabilities: a.probabilities.slice() } };
+  } catch {
+    return { ok: false, reason: "malformed" };
+  }
+}
+function classifierStateForFact(fact) {
+  const parts = [fact.title, fact.body];
+  if (Array.isArray(fact.tags) && fact.tags.length > 0) parts.push(`Tags: ${fact.tags.join(", ")}`);
+  return parts.join("\n\n");
+}
+
 // src/utils/embedding.ts
 function parseEmbedding(blob, text) {
   if (blob && blob.byteLength > 0) {
@@ -3191,7 +3235,7 @@ var MaintenanceService = class {
     if (!ontologyService) {
       return { ...zeroed, remaining: 0, deferred: 0 };
     }
-    const { mode } = await ontologyService.getEffectiveState(entityId);
+    const { mode, manifest: effectiveManifest } = await ontologyService.getEffectiveState(entityId);
     if (mode === "off") {
       const counts2 = await this.entryRepo.countUntypedByEntityId(entityId, recheckCutoff);
       return { ...zeroed, remaining: 0, deferred: counts2.deferred };
@@ -3201,6 +3245,14 @@ var MaintenanceService = class {
       const counts2 = await this.entryRepo.countUntypedByEntityId(entityId, recheckCutoff);
       return { ...zeroed, remaining: counts2.eligible, deferred: counts2.deferred };
     }
+    const classifierMode = options?.classifier ?? this.options.config?.ontology?.backfillClassifier ?? "llm";
+    const classify = this.options.llmProvider.classify;
+    if (classifierMode === "auto" && typeof classify === "function") {
+      const slugs = effectiveManifest.node_types.map((n) => n.type);
+      if (slugs.length > 0 && slugs.length <= 255) {
+        return this._runClassifierBackfill(entityId, candidates, effectiveManifest, now, recheckCutoff);
+      }
+    }
     const ontologyContext = await ontologyService.buildPromptContext(entityId);
     const toPromptShape = (f) => ({ id: f.id, title: f.title, body: f.body, tags: f.tags });
     const buildPrompt = (facts) => this.promptService.buildOntologyBackfillPrompt(
@@ -3279,6 +3331,87 @@ var MaintenanceService = class {
       deferred: counts.deferred
     };
   }
+  /**
+   * Classifier-mode backfill (spec §7.3): one `choice` question per untyped
+   * fact over the effective manifest's node-type slugs. Accepted answers go
+   * through `_applyOntologyBackfillBatch` exactly like LLM classifications.
+   * No edges are proposed.
+   */
+  async _runClassifierBackfill(entityId, candidates, manifest, now, recheckCutoff) {
+    const provider = this.options.llmProvider;
+    const rawMin = this.options.config?.ontology?.classifyMinConfidence;
+    const minConfidence = typeof rawMin === "number" && Number.isFinite(rawMin) && rawMin >= 0 && rawMin <= 1 ? rawMin : 0.5;
+    const rawConcurrency = this.options.config?.chunkConcurrency ?? 1;
+    const concurrency = Number.isFinite(rawConcurrency) && rawConcurrency >= 1 ? Math.floor(rawConcurrency) : 1;
+    const question = {
+      kind: "choice",
+      options: manifest.node_types.map((n) => n.type),
+      instructions: "Choose the ontology node type that best describes this fact.\n" + manifest.node_types.map((n) => `- ${n.type}: ${n.description}`).join("\n")
+    };
+    const outcomes = await withConcurrency(
+      candidates.map((fact) => async () => {
+        let response;
+        try {
+          response = await provider.classify({ state: classifierStateForFact(fact), questions: { okf_type: question } });
+        } catch {
+          return { fact, kind: "threw" };
+        }
+        const checked = validateClassifierAnswer(response, "okf_type", question);
+        if (!checked.ok) return { fact, kind: "invalid", reason: checked.reason };
+        if (checked.answer.kind !== "choice") return { fact, kind: "invalid", reason: "kind_mismatch" };
+        if (checked.answer.confidence < minConfidence) return { fact, kind: "low_confidence" };
+        return { fact, kind: "accepted", okfType: checked.answer.choice };
+      }),
+      concurrency
+    );
+    const attempted = outcomes.filter((o) => o.kind !== "threw").map((o) => o.fact);
+    const skipped = outcomes.length - attempted.length;
+    const classifications = outcomes.filter((o) => o.kind === "accepted").map((o) => ({ id: o.fact.id, okf_type: o.okfType }));
+    const invalidCount = outcomes.filter((o) => o.kind === "invalid").length;
+    let typed = 0;
+    let failedValidation = 0;
+    let edgesAdded = 0;
+    let aborted = false;
+    if (attempted.length > 0) {
+      const applied = await this._applyOntologyBackfillBatch(
+        entityId,
+        { batch: attempted, classifications, ontologyUpdates: void 0 },
+        now
+      );
+      aborted = applied.abortedOntologyOff;
+      if (!aborted) {
+        typed = applied.typed;
+        failedValidation = invalidCount + applied.failedValidation;
+        edgesAdded = applied.edgesAdded;
+      }
+    }
+    const diagBuffer = new DiagnosticBuffer();
+    const diagBase = { entityId, operation: "ontologyBackfill", trigger: "call" };
+    for (const o of outcomes) {
+      if (o.kind === "low_confidence") {
+        diagBuffer.push({ ...diagBase, code: "classification_low_confidence", detail: { factId: o.fact.id, reason: "below_threshold" } });
+      } else if (o.kind === "invalid") {
+        diagBuffer.push({ ...diagBase, code: "classification_invalid", detail: { factId: o.fact.id, reason: o.reason } });
+      } else if (o.kind === "threw") {
+        diagBuffer.push({ ...diagBase, code: "classification_invalid", detail: { factId: o.fact.id, reason: "classify_threw" } });
+      }
+    }
+    diagBuffer.flush(this.options);
+    const counts = await this.entryRepo.countUntypedByEntityId(entityId, recheckCutoff);
+    if (aborted) {
+      return { scanned: 0, typed: 0, failedValidation: 0, edgesAdded: 0, skipped, remaining: 0, deferred: counts.deferred };
+    }
+    this.searchService.evictCache(entityId);
+    return {
+      scanned: candidates.length,
+      typed,
+      failedValidation,
+      edgesAdded,
+      skipped,
+      remaining: counts.eligible,
+      deferred: counts.deferred
+    };
+  }
   /**
    * Applies one parsed backfill batch in its own transaction. Per-batch rather
    * than one transaction for the pass, so mergeEmergentUpdates semantics and
@@ -3563,7 +3696,6 @@ var RetrievalService = class {
     const hybridWeight = options?.hybridWeight ?? config?.hybridWeight;
     const weight = hybridWeight !== void 0 && !Number.isNaN(hybridWeight) ? Math.max(0, Math.min(1, hybridWeight)) : void 0;
     const skipEmbed = weight === 0;
-    const embedFn = this.options.llmProvider.embed;
     let facts = [];
     let scoreByFactId;
     if (maxResults === 0) ; else if (trimmedQuery) {
@@ -3574,11 +3706,11 @@ var RetrievalService = class {
       const padLimit = (n) => n >= Number.MAX_SAFE_INTEGER ? n : n + draftPad;
       if (scoredEntityIds.length === 0) {
         usedEmbed = true;
-      } else if (!skipEmbed && embedFn) {
+      } else if (!skipEmbed && typeof this.options.llmProvider.embed === "function") {
         let rankerShouldRethrow = false;
         let pendingRankerFallbackError;
         try {
-          const queryVec = await embedFn(trimmedQuery);
+          const queryVec = await this.options.llmProvider.embed(trimmedQuery);
           if (queryVec.length === 0 || !queryVec.every((v) => typeof v === "number" && isFinite(v))) {
             throw new Error(
               "embed() returned an empty or non-finite vector. Falling back to keyword search."