@equationalapplications/core-llm-wiki 5.5.1 → 6.0.1

package/dist/{testing-D0RnZjyW.d.mts → testing-DgqVB29I.d.mts}

@@ -101,6 +101,20 @@ interface OntologyBackfillResult {
      * Stamped with the recheck cooldown, so they reappear as `deferred` next pass. */
     skipped: number;
 }
+/**
+ * L3 heal-success record: a fact the model emitted a verdict for under a
+ * truncated view of its own body. `originalBodyChars` lets an operator flag
+ * the fact for re-inspection; `truncatedBodyChars` is the L3 cap actually
+ * applied. Emitted by `PromptService.buildHealPrompt`, surfaced via
+ * `HealResult.degraded`, mutually exclusive with `HealResult.skipped` on
+ * `id` (a fact can be either healed-under-degradation or dropped — never
+ * both).
+ */
+interface DegradedRecord {
+    id: string;
+    originalBodyChars: number;
+    truncatedBodyChars: number;
+}
 /** Result of a single heal run. */
 interface HealResult {
     /**
@@ -118,8 +132,32 @@ interface HealResult {
     deleted: number;
     /** New facts synthesized by heal. */
     newFactsCreated: number;
-    /** Candidates a batch could not process even alone, skipped so the pass could finish. */
-    skipped: number;
+    /**
+     * Candidates that could not converge after the helper's full escalation
+     * path. `reason` distinguishes genuine non-convergence
+     * (`'non_convergent'` — terminal give-up at attemptLevel 3, parse error,
+     * or model-config error) from transient provider failures
+     * (`'call_error'` — non-truncation error originating in `call()` at
+     * `batch.length === 1`). `doRunHeal` excludes `'call_error'` ids from
+     * `markHealChecked`'s cooldown stamp so a momentary provider hiccup does
+     * not lock the fact out for `HEAL_RECHECK_MS`. Mutually exclusive with
+     * `degraded` on `id`.
+     */
+    skipped: Array<{
+        id: string;
+        reason: 'non_convergent' | 'call_error';
+    }>;
+    /**
+     * L3 heal successes: facts the model emitted a verdict for under a
+     * truncated view of their own body. Each entry carries the truncation
+     * magnitude so an operator can flag the fact for re-inspection. The
+     * corresponding log line `[WikiMemory] heal healed under degraded
+     * context ...` fires for each entry. Mutually exclusive with `skipped`
+     * on `id` — the reconciliation step in doRunHeal drops any record
+     * whose id also appears in `skipped` (a contradiction: degraded means
+     * healed, skipped means dropped).
+     */
+    degraded: Array<DegradedRecord>;
     /**
      * Heal candidates still eligible after this run — convergence signal: loop while > 0.
      *
@@ -1530,9 +1568,34 @@ declare class PromptService {
         systemPrompt: string;
         userPrompt: string;
     };
-    buildHealPrompt(healCandidates: unknown[], documentAnchors: unknown[], allTasks: unknown[], recentEvents: unknown[], runtimeOverride?: string): {
-        systemPrompt: string;
-        userPrompt: string;
+    /**
+     * Heal-prompt level interpretation for the `attemptLevel` ladder.
+     *
+     * Caller contract: `documentAnchors` may be a slice sized for `batch.length`
+     * or a larger set (e.g. a cache hit from `_selectHealAnchors`). This function
+     * applies the prompt-side anchor cap `min(HEAL_MAX_ANCHORS=50, batch.length
+     * * HEAL_ANCHORS_PER_CANDIDATE=4)` so the rendered prompt is bounded
+     * regardless of caller input. `HEAL_MAX_ANCHORS` and
+     * `HEAL_ANCHORS_PER_CANDIDATE` live here too — keeping the formula
+     * co-located with its application avoids a "MaintenanceService policy"
+     * import cycle (`PromptService` is constructed before `MaintenanceService`
+     * exists) and makes the cap testable without a `MaintenanceService`
+     * instance. Task 3 exports the same two constants from `MaintenanceService`
+     * for caller-side overfetch sizing; the values must match.
+     *
+     * Level semantics:
+     * - L0: allTasks + recentEvents + full candidate bodies; anchors re-capped
+     * - L1: drop allTasks; recentEvents present; candidate bodies full
+     * - L2: drop allTasks and recentEvents; candidate bodies full
+     * - L3: drop allTasks and recentEvents; truncate each candidate body to
+     *   `bodyTruncationChars` and emit a `degraded` record per truncated fact
+     */
+    buildHealPrompt(healCandidates: unknown[], documentAnchors: unknown[], allTasks: unknown[], recentEvents: unknown[], runtimeOverride: string | undefined, attemptLevel: 0 | 1 | 2 | 3, bodyTruncationChars?: number): {
+        prompts: {
+            systemPrompt: string;
+            userPrompt: string;
+        };
+        degraded: DegradedRecord[];
     };
     buildOntologyBackfillPrompt(facts: unknown[], runtimeOverride?: string, ontologyContext?: OntologyPromptContext | null): {
         systemPrompt: string;
@@ -1748,6 +1811,7 @@ declare class EventRepository extends BaseRepository {
 declare const ONTOLOGY_BACKFILL_BATCH_SIZE = 25;
 declare const ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS = 40000;
 declare const ONTOLOGY_BACKFILL_RECHECK_MS: number;
+
 /**
  * Heal candidates fetched per pass. Bounds the pool runBatched draws from, not
  * the size of an individual LLM call — runBatched still packs ~10 candidates per
@@ -1787,6 +1851,7 @@ declare class MaintenanceService {
     runHeal(entityId: string, options?: {
         promptOverride?: string;
         batchSize?: number;
+        bodyTruncationChars?: number;
     }): Promise<HealResult>;
     runOntologyBackfill(entityId: string, options?: {
         promptOverride?: string;
@@ -1840,6 +1905,7 @@ declare class MaintenanceService {
     doRunHeal(entityId: string, options?: {
         promptOverride?: string;
         batchSize?: number;
+        bodyTruncationChars?: number;
     }): Promise<HealResult>;
     /** Core ontology backfill pass (locks handled by {@link runOntologyBackfill}). Package-internal orchestration hook. */
     doRunOntologyBackfill(entityId: string, options?: {
@@ -2304,4 +2370,4 @@ declare class WikiMemory {
     setGeneratedByTask(taskId: string, entityId: string, actor: string): Promise<void>;
 }
 
-export { WikiStrictOntologyViolation as $, WikiBusyError as A, type WikiBusyOperation as B, type ChunkFailure as C, type WikiCheckpoint as D, type EntityStatus as E, type FormatContextOptions as F, type GraphNeighborhood as G, HEAL_BATCH_SIZE as H, type IngestDocumentResult as I, type WikiConfig as J, WikiDuplicateHashError as K, type LLMProvider as L, type MemoryBundle as M, type WikiEdge as N, type OntologyManifest as O, type PromptOverrides as P, type WikiEvent as Q, type ReadOptions as R, type SQLiteAdapter as S, type WikiFact as T, WikiIngestEmptyError as U, type VectorRanker as V, type WikiOptions as W, type WikiMemoryTestAccess as X, type WikiOutboxEvent as Y, WikiParseError as Z, WikiSourceRefHashCollision as _, type MemoryDump as a, type WikiTask as a0, WikiTransactionError as a1, EmbeddingService as a2, ImportExportService as a3, IngestionService as a4, JobManager as a5, MaintenanceService as a6, RetrievalService as a7, SearchService as a8, WriteService as a9, type FormattedMemoryDump as b, WikiMemory as c, type ExtractedFact as d, type ExtractedFactEdge as e, type ExtractedFactWithOntology as f, type ExtractedTask as g, type GraphTraversalOptions as h, HEAL_RECHECK_MS as i, HOOK_TIMEOUT_MARKER as j, type HealResult as k, ONTOLOGY_BACKFILL_BATCH_SIZE as l, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS as m, ONTOLOGY_BACKFILL_RECHECK_MS as n, type OntologyBackfillResult as o, type OntologyConfig as p, type OntologyEdgeType as q, type OntologyMode as r, type OntologyNodeType as s, type OntologyPromptContext as t, type OntologyUpdates as u, PromptService as v, PrunePartialFailureError as w, type VectorRankerFallback as x, type VectorRankerRankArgs as y, type VectorRankerSemanticResult as z };
+export { WikiSourceRefHashCollision as $, WikiBusyError as A, type WikiBusyOperation as B, type ChunkFailure as C, type DegradedRecord as D, type EntityStatus as E, type FormatContextOptions as F, type GraphNeighborhood as G, HEAL_BATCH_SIZE as H, type IngestDocumentResult as I, type WikiCheckpoint as J, type WikiConfig as K, type LLMProvider as L, type MemoryBundle as M, WikiDuplicateHashError as N, type OntologyManifest as O, type PromptOverrides as P, type WikiEdge as Q, type ReadOptions as R, type SQLiteAdapter as S, type WikiEvent as T, type WikiFact as U, type VectorRanker as V, type WikiOptions as W, WikiIngestEmptyError as X, type WikiMemoryTestAccess as Y, type WikiOutboxEvent as Z, WikiParseError as _, type MemoryDump as a, WikiStrictOntologyViolation as a0, type WikiTask as a1, WikiTransactionError as a2, EmbeddingService as a3, ImportExportService as a4, IngestionService as a5, JobManager as a6, MaintenanceService as a7, RetrievalService as a8, SearchService as a9, WriteService as aa, type FormattedMemoryDump as b, WikiMemory as c, type ExtractedFact as d, type ExtractedFactEdge as e, type ExtractedFactWithOntology as f, type ExtractedTask as g, type GraphTraversalOptions as h, HEAL_RECHECK_MS as i, HOOK_TIMEOUT_MARKER as j, type HealResult as k, ONTOLOGY_BACKFILL_BATCH_SIZE as l, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS as m, ONTOLOGY_BACKFILL_RECHECK_MS as n, type OntologyBackfillResult as o, type OntologyConfig as p, type OntologyEdgeType as q, type OntologyMode as r, type OntologyNodeType as s, type OntologyPromptContext as t, type OntologyUpdates as u, PromptService as v, PrunePartialFailureError as w, type VectorRankerFallback as x, type VectorRankerRankArgs as y, type VectorRankerSemanticResult as z };

package/dist/{testing-D0RnZjyW.d.ts → testing-DgqVB29I.d.ts}

@@ -101,6 +101,20 @@ interface OntologyBackfillResult {
      * Stamped with the recheck cooldown, so they reappear as `deferred` next pass. */
     skipped: number;
 }
+/**
+ * L3 heal-success record: a fact the model emitted a verdict for under a
+ * truncated view of its own body. `originalBodyChars` lets an operator flag
+ * the fact for re-inspection; `truncatedBodyChars` is the L3 cap actually
+ * applied. Emitted by `PromptService.buildHealPrompt`, surfaced via
+ * `HealResult.degraded`, mutually exclusive with `HealResult.skipped` on
+ * `id` (a fact can be either healed-under-degradation or dropped — never
+ * both).
+ */
+interface DegradedRecord {
+    id: string;
+    originalBodyChars: number;
+    truncatedBodyChars: number;
+}
 /** Result of a single heal run. */
 interface HealResult {
     /**
@@ -118,8 +132,32 @@ interface HealResult {
     deleted: number;
     /** New facts synthesized by heal. */
     newFactsCreated: number;
-    /** Candidates a batch could not process even alone, skipped so the pass could finish. */
-    skipped: number;
+    /**
+     * Candidates that could not converge after the helper's full escalation
+     * path. `reason` distinguishes genuine non-convergence
+     * (`'non_convergent'` — terminal give-up at attemptLevel 3, parse error,
+     * or model-config error) from transient provider failures
+     * (`'call_error'` — non-truncation error originating in `call()` at
+     * `batch.length === 1`). `doRunHeal` excludes `'call_error'` ids from
+     * `markHealChecked`'s cooldown stamp so a momentary provider hiccup does
+     * not lock the fact out for `HEAL_RECHECK_MS`. Mutually exclusive with
+     * `degraded` on `id`.
+     */
+    skipped: Array<{
+        id: string;
+        reason: 'non_convergent' | 'call_error';
+    }>;
+    /**
+     * L3 heal successes: facts the model emitted a verdict for under a
+     * truncated view of their own body. Each entry carries the truncation
+     * magnitude so an operator can flag the fact for re-inspection. The
+     * corresponding log line `[WikiMemory] heal healed under degraded
+     * context ...` fires for each entry. Mutually exclusive with `skipped`
+     * on `id` — the reconciliation step in doRunHeal drops any record
+     * whose id also appears in `skipped` (a contradiction: degraded means
+     * healed, skipped means dropped).
+     */
+    degraded: Array<DegradedRecord>;
     /**
      * Heal candidates still eligible after this run — convergence signal: loop while > 0.
      *
@@ -1530,9 +1568,34 @@ declare class PromptService {
         systemPrompt: string;
         userPrompt: string;
     };
-    buildHealPrompt(healCandidates: unknown[], documentAnchors: unknown[], allTasks: unknown[], recentEvents: unknown[], runtimeOverride?: string): {
-        systemPrompt: string;
-        userPrompt: string;
+    /**
+     * Heal-prompt level interpretation for the `attemptLevel` ladder.
+     *
+     * Caller contract: `documentAnchors` may be a slice sized for `batch.length`
+     * or a larger set (e.g. a cache hit from `_selectHealAnchors`). This function
+     * applies the prompt-side anchor cap `min(HEAL_MAX_ANCHORS=50, batch.length
+     * * HEAL_ANCHORS_PER_CANDIDATE=4)` so the rendered prompt is bounded
+     * regardless of caller input. `HEAL_MAX_ANCHORS` and
+     * `HEAL_ANCHORS_PER_CANDIDATE` live here too — keeping the formula
+     * co-located with its application avoids a "MaintenanceService policy"
+     * import cycle (`PromptService` is constructed before `MaintenanceService`
+     * exists) and makes the cap testable without a `MaintenanceService`
+     * instance. Task 3 exports the same two constants from `MaintenanceService`
+     * for caller-side overfetch sizing; the values must match.
+     *
+     * Level semantics:
+     * - L0: allTasks + recentEvents + full candidate bodies; anchors re-capped
+     * - L1: drop allTasks; recentEvents present; candidate bodies full
+     * - L2: drop allTasks and recentEvents; candidate bodies full
+     * - L3: drop allTasks and recentEvents; truncate each candidate body to
+     *   `bodyTruncationChars` and emit a `degraded` record per truncated fact
+     */
+    buildHealPrompt(healCandidates: unknown[], documentAnchors: unknown[], allTasks: unknown[], recentEvents: unknown[], runtimeOverride: string | undefined, attemptLevel: 0 | 1 | 2 | 3, bodyTruncationChars?: number): {
+        prompts: {
+            systemPrompt: string;
+            userPrompt: string;
+        };
+        degraded: DegradedRecord[];
     };
     buildOntologyBackfillPrompt(facts: unknown[], runtimeOverride?: string, ontologyContext?: OntologyPromptContext | null): {
         systemPrompt: string;
@@ -1748,6 +1811,7 @@ declare class EventRepository extends BaseRepository {
 declare const ONTOLOGY_BACKFILL_BATCH_SIZE = 25;
 declare const ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS = 40000;
 declare const ONTOLOGY_BACKFILL_RECHECK_MS: number;
+
 /**
  * Heal candidates fetched per pass. Bounds the pool runBatched draws from, not
  * the size of an individual LLM call — runBatched still packs ~10 candidates per
@@ -1787,6 +1851,7 @@ declare class MaintenanceService {
     runHeal(entityId: string, options?: {
         promptOverride?: string;
         batchSize?: number;
+        bodyTruncationChars?: number;
     }): Promise<HealResult>;
     runOntologyBackfill(entityId: string, options?: {
         promptOverride?: string;
@@ -1840,6 +1905,7 @@ declare class MaintenanceService {
     doRunHeal(entityId: string, options?: {
         promptOverride?: string;
         batchSize?: number;
+        bodyTruncationChars?: number;
     }): Promise<HealResult>;
     /** Core ontology backfill pass (locks handled by {@link runOntologyBackfill}). Package-internal orchestration hook. */
     doRunOntologyBackfill(entityId: string, options?: {
@@ -2304,4 +2370,4 @@ declare class WikiMemory {
     setGeneratedByTask(taskId: string, entityId: string, actor: string): Promise<void>;
 }
 
-export { WikiStrictOntologyViolation as $, WikiBusyError as A, type WikiBusyOperation as B, type ChunkFailure as C, type WikiCheckpoint as D, type EntityStatus as E, type FormatContextOptions as F, type GraphNeighborhood as G, HEAL_BATCH_SIZE as H, type IngestDocumentResult as I, type WikiConfig as J, WikiDuplicateHashError as K, type LLMProvider as L, type MemoryBundle as M, type WikiEdge as N, type OntologyManifest as O, type PromptOverrides as P, type WikiEvent as Q, type ReadOptions as R, type SQLiteAdapter as S, type WikiFact as T, WikiIngestEmptyError as U, type VectorRanker as V, type WikiOptions as W, type WikiMemoryTestAccess as X, type WikiOutboxEvent as Y, WikiParseError as Z, WikiSourceRefHashCollision as _, type MemoryDump as a, type WikiTask as a0, WikiTransactionError as a1, EmbeddingService as a2, ImportExportService as a3, IngestionService as a4, JobManager as a5, MaintenanceService as a6, RetrievalService as a7, SearchService as a8, WriteService as a9, type FormattedMemoryDump as b, WikiMemory as c, type ExtractedFact as d, type ExtractedFactEdge as e, type ExtractedFactWithOntology as f, type ExtractedTask as g, type GraphTraversalOptions as h, HEAL_RECHECK_MS as i, HOOK_TIMEOUT_MARKER as j, type HealResult as k, ONTOLOGY_BACKFILL_BATCH_SIZE as l, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS as m, ONTOLOGY_BACKFILL_RECHECK_MS as n, type OntologyBackfillResult as o, type OntologyConfig as p, type OntologyEdgeType as q, type OntologyMode as r, type OntologyNodeType as s, type OntologyPromptContext as t, type OntologyUpdates as u, PromptService as v, PrunePartialFailureError as w, type VectorRankerFallback as x, type VectorRankerRankArgs as y, type VectorRankerSemanticResult as z };
+export { WikiSourceRefHashCollision as $, WikiBusyError as A, type WikiBusyOperation as B, type ChunkFailure as C, type DegradedRecord as D, type EntityStatus as E, type FormatContextOptions as F, type GraphNeighborhood as G, HEAL_BATCH_SIZE as H, type IngestDocumentResult as I, type WikiCheckpoint as J, type WikiConfig as K, type LLMProvider as L, type MemoryBundle as M, WikiDuplicateHashError as N, type OntologyManifest as O, type PromptOverrides as P, type WikiEdge as Q, type ReadOptions as R, type SQLiteAdapter as S, type WikiEvent as T, type WikiFact as U, type VectorRanker as V, type WikiOptions as W, WikiIngestEmptyError as X, type WikiMemoryTestAccess as Y, type WikiOutboxEvent as Z, WikiParseError as _, type MemoryDump as a, WikiStrictOntologyViolation as a0, type WikiTask as a1, WikiTransactionError as a2, EmbeddingService as a3, ImportExportService as a4, IngestionService as a5, JobManager as a6, MaintenanceService as a7, RetrievalService as a8, SearchService as a9, WriteService as aa, type FormattedMemoryDump as b, WikiMemory as c, type ExtractedFact as d, type ExtractedFactEdge as e, type ExtractedFactWithOntology as f, type ExtractedTask as g, type GraphTraversalOptions as h, HEAL_RECHECK_MS as i, HOOK_TIMEOUT_MARKER as j, type HealResult as k, ONTOLOGY_BACKFILL_BATCH_SIZE as l, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS as m, ONTOLOGY_BACKFILL_RECHECK_MS as n, type OntologyBackfillResult as o, type OntologyConfig as p, type OntologyEdgeType as q, type OntologyMode as r, type OntologyNodeType as s, type OntologyPromptContext as t, type OntologyUpdates as u, PromptService as v, PrunePartialFailureError as w, type VectorRankerFallback as x, type VectorRankerRankArgs as y, type VectorRankerSemanticResult as z };

package/dist/testing.d.mts

@@ -1,3 +1,3 @@
-export { a2 as EmbeddingService, a3 as ImportExportService, a4 as IngestionService, a5 as JobManager, a5 as JobManagerType, a6 as MaintenanceService, a7 as RetrievalService, a8 as SearchService, a8 as SearchServiceType, X as WikiMemoryTestAccess, a9 as WriteService } from './testing-D0RnZjyW.mjs';
+export { a3 as EmbeddingService, a4 as ImportExportService, a5 as IngestionService, a6 as JobManager, a6 as JobManagerType, a7 as MaintenanceService, a8 as RetrievalService, a9 as SearchService, a9 as SearchServiceType, Y as WikiMemoryTestAccess, aa as WriteService } from './testing-DgqVB29I.mjs';
 import '@equationalapplications/core-okf';
 import 'minisearch';

package/dist/testing.d.ts

@@ -1,3 +1,3 @@
-export { a2 as EmbeddingService, a3 as ImportExportService, a4 as IngestionService, a5 as JobManager, a5 as JobManagerType, a6 as MaintenanceService, a7 as RetrievalService, a8 as SearchService, a8 as SearchServiceType, X as WikiMemoryTestAccess, a9 as WriteService } from './testing-D0RnZjyW.js';
+export { a3 as EmbeddingService, a4 as ImportExportService, a5 as IngestionService, a6 as JobManager, a6 as JobManagerType, a7 as MaintenanceService, a8 as RetrievalService, a9 as SearchService, a9 as SearchServiceType, Y as WikiMemoryTestAccess, aa as WriteService } from './testing-DgqVB29I.js';
 import '@equationalapplications/core-okf';
 import 'minisearch';

package/dist/testing.js

@@ -1270,6 +1270,12 @@ Return ONLY a valid JSON object matching this schema:
 If no manifest type fits a fact, omit that fact from "classifications" entirely \u2014 do not guess.
 When echoing an existing fact's title verbatim into "target_title", preserve every JSON escape sequence (\\", \\n, \\\\, \\/) exactly as it appeared in the input body \u2014 do not strip backslashes, do not add unescaped quotes. Do not return markdown, just raw JSON.`;
 
+// src/utils/healConstants.ts
+var HEAL_MAX_ANCHORS = 50;
+var HEAL_ANCHORS_PER_CANDIDATE = 4;
+var HEAL_MAX_FACT_BODY_CHARS_L3 = 4e3;
+var HEAL_MAX_TASKS = 50;
+
 // src/services/PromptService.ts
 var PromptService = class {
   constructor(globalOverrides) {
@@ -1337,25 +1343,67 @@ Current Facts:
 ${JSON.stringify(currentFacts, null, 2)}`
     };
   }
-  buildHealPrompt(healCandidates, documentAnchors, allTasks, recentEvents, runtimeOverride) {
+  /**
+   * Heal-prompt level interpretation for the `attemptLevel` ladder.
+   *
+   * Caller contract: `documentAnchors` may be a slice sized for `batch.length`
+   * or a larger set (e.g. a cache hit from `_selectHealAnchors`). This function
+   * applies the prompt-side anchor cap `min(HEAL_MAX_ANCHORS=50, batch.length
+   * * HEAL_ANCHORS_PER_CANDIDATE=4)` so the rendered prompt is bounded
+   * regardless of caller input. `HEAL_MAX_ANCHORS` and
+   * `HEAL_ANCHORS_PER_CANDIDATE` live here too — keeping the formula
+   * co-located with its application avoids a "MaintenanceService policy"
+   * import cycle (`PromptService` is constructed before `MaintenanceService`
+   * exists) and makes the cap testable without a `MaintenanceService`
+   * instance. Task 3 exports the same two constants from `MaintenanceService`
+   * for caller-side overfetch sizing; the values must match.
+   *
+   * Level semantics:
+   * - L0: allTasks + recentEvents + full candidate bodies; anchors re-capped
+   * - L1: drop allTasks; recentEvents present; candidate bodies full
+   * - L2: drop allTasks and recentEvents; candidate bodies full
+   * - L3: drop allTasks and recentEvents; truncate each candidate body to
+   *   `bodyTruncationChars` and emit a `degraded` record per truncated fact
+   */
+  buildHealPrompt(healCandidates, documentAnchors, allTasks, recentEvents, runtimeOverride, attemptLevel, bodyTruncationChars = HEAL_MAX_FACT_BODY_CHARS_L3) {
+    const effectiveTasks = attemptLevel >= 1 ? [] : allTasks;
+    const effectiveEvents = attemptLevel >= 2 ? [] : recentEvents;
+    const maxAnchors = Math.max(1, Math.min(HEAL_MAX_ANCHORS, healCandidates.length * HEAL_ANCHORS_PER_CANDIDATE));
+    const effectiveAnchors = documentAnchors.slice(0, maxAnchors);
+    const { shapedCandidates, degraded } = applyBodyTruncation(
+      healCandidates,
+      attemptLevel,
+      bodyTruncationChars
+    );
     const template = runtimeOverride ?? this.globalOverrides?.healSystemPrompt ?? HEAL_SYSTEM_PROMPT;
     if (/\{\{\s*healCandidates\s*\}\}/.test(template) || /\{\{\s*documentAnchors\s*\}\}/.test(template) || /\{\{\s*allTasks\s*\}\}/.test(template) || /\{\{\s*recentEvents\s*\}\}/.test(template)) {
       return {
-        systemPrompt: this.hydrate(template, { healCandidates, documentAnchors, allTasks, recentEvents }),
-        userPrompt: "Please heal the memory graph."
+        prompts: {
+          systemPrompt: this.hydrate(template, {
+            healCandidates: shapedCandidates,
+            documentAnchors: effectiveAnchors,
+            allTasks: effectiveTasks,
+            recentEvents: effectiveEvents
+          }),
+          userPrompt: "Please heal the memory graph."
+        },
+        degraded
       };
     }
     return {
-      systemPrompt: template,
-      userPrompt: `Heal Candidates:
-${JSON.stringify(healCandidates, null, 2)}
+      prompts: {
+        systemPrompt: template,
+        userPrompt: `Heal Candidates:
+${JSON.stringify(shapedCandidates, null, 2)}
 Document Anchors (DO NOT MODIFY OR DELETE):
-${JSON.stringify(documentAnchors, null, 2)}
+${JSON.stringify(effectiveAnchors, null, 2)}
 All Tasks:
-${JSON.stringify(allTasks, null, 2)}
+${JSON.stringify(effectiveTasks, null, 2)}
 Recent Events:
-${JSON.stringify(recentEvents, null, 2)}
+${JSON.stringify(effectiveEvents, null, 2)}
 The following document anchors are provided for contradiction detection only. Do not include them in \`downgraded\`, \`deleted\`, or \`newFacts\`.`
+      },
+      degraded
     };
   }
   buildOntologyBackfillPrompt(facts, runtimeOverride, ontologyContext) {
@@ -1375,6 +1423,36 @@ ${JSON.stringify(facts, null, 2)}`
     };
   }
 };
+function applyBodyTruncation(candidates, attemptLevel, bodyTruncationChars) {
+  if (attemptLevel < 3) {
+    return { shapedCandidates: candidates, degraded: [] };
+  }
+  const shapedCandidates = [];
+  const degraded = [];
+  for (const c of candidates) {
+    if (typeof c !== "object" || c === null) {
+      shapedCandidates.push(c);
+      continue;
+    }
+    const fact = c;
+    const body = typeof fact.body === "string" ? fact.body : "";
+    if (body.length <= bodyTruncationChars) {
+      shapedCandidates.push(c);
+      continue;
+    }
+    if (typeof fact.id !== "string") {
+      shapedCandidates.push(c);
+      continue;
+    }
+    const originalBodyChars = body.length;
+    const prefix = safeSlice(body, 0, bodyTruncationChars);
+    const truncatedBodyChars = prefix.length;
+    const truncated = `${prefix}\u2026[truncated at ${truncatedBodyChars} chars, original was ${originalBodyChars}]`;
+    shapedCandidates.push({ ...fact, body: truncated });
+    degraded.push({ id: fact.id, originalBodyChars, truncatedBodyChars });
+  }
+  return { shapedCandidates, degraded };
+}
 
 // src/utils/chunkingDefaults.ts
 var DEFAULT_MAX_CHUNK_LENGTH = 12e3;
@@ -1885,16 +1963,24 @@ var TRUNCATION_PATTERNS = [
   /finish[_ ]?reason/i
 ];
 var EXCEEDS_LIMIT_PATTERN = /exceed[a-z]*[^.]{0,40}\b(model|context)?[ _-]?limit/i;
-function isTruncationError(err) {
-  let message;
+function getErrorMessage(err) {
   try {
-    message = err instanceof Error ? err.message : String(err ?? "");
+    return err instanceof Error ? err.message : String(err ?? "");
   } catch {
-    return false;
+    return void 0;
   }
+}
+function isTruncationError(err) {
+  const message = getErrorMessage(err);
+  if (message === void 0) return false;
   if (EXCEEDS_LIMIT_PATTERN.test(message)) return false;
   return TRUNCATION_PATTERNS.some((pattern) => pattern.test(message));
 }
+function isConfigError(err) {
+  const message = getErrorMessage(err);
+  if (message === void 0) return false;
+  return EXCEEDS_LIMIT_PATTERN.test(message);
+}
 function initialBatchSize(maxOutputTokens) {
   if (!maxOutputTokens || !Number.isFinite(maxOutputTokens) || maxOutputTokens <= 0) {
     return DEFAULT_BATCH_SIZE;
@@ -1936,14 +2022,18 @@ async function runBatched(args) {
     const single = candidate.slice(0, 1);
     return { batch: single, prompts: await buildPrompt(single) };
   };
-  const onFailure = async (batch, err) => {
-    if (batch.length <= 1) {
-      if (batch.length === 1) {
-        skipped.push(batch[0]);
+  const onFailure = async (batch, err, attemptLevel, fromCall) => {
+    if (batch.length === 1) {
+      if (fromCall && isTruncationError(err) && attemptLevel < 3) {
+        await attempt(batch, void 0, attemptLevel + 1);
+      } else {
+        const reason = fromCall && !isTruncationError(err) && !isConfigError(err) ? "call_error" : "non_convergent";
+        skipped.push({ item: batch[0], reason });
         onSkip?.(batch[0], err);
       }
       return;
     }
+    if (fromCall && !isTruncationError(err)) throw err;
     const mid = Math.ceil(batch.length / 2);
     if (mid < batchSize) batchSize = mid;
     let i = 0;
@@ -1954,23 +2044,22 @@ async function runBatched(args) {
       i += trimmed.batch.length;
     }
   };
-  const attempt = async (batch, prebuilt) => {
+  const attempt = async (batch, prebuilt, attemptLevel = 0) => {
     if (batch.length === 0) return;
-    const prompts = prebuilt ?? await buildPrompt(batch);
+    const prompts = prebuilt && attemptLevel === 0 ? prebuilt : await buildPrompt(batch, attemptLevel);
     batches++;
     let responseText;
     try {
       responseText = await call(prompts);
     } catch (err) {
-      if (!isTruncationError(err)) throw err;
-      await onFailure(batch, err);
+      await onFailure(batch, err, attemptLevel, true);
       return;
     }
     let result;
     try {
       result = parse(responseText, batch);
     } catch (err) {
-      await onFailure(batch, err);
+      await onFailure(batch, err, attemptLevel, false);
       return;
     }
     results.push(result);
@@ -1979,7 +2068,7 @@ async function runBatched(args) {
   while (index < items.length) {
     const { batch, prompts } = await trim(items.slice(index, index + batchSize));
     index += batch.length;
-    await attempt(batch, prompts);
+    await attempt(batch, prompts, 0);
   }
   return { results, skipped, batches };
 }
@@ -1990,7 +2079,6 @@ var MIN_TOKENS_TO_QUALIFY = 3;
 var ONTOLOGY_BACKFILL_BATCH_SIZE = 25;
 var ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS = 4e4;
 var ONTOLOGY_BACKFILL_RECHECK_MS = 7 * 24 * 60 * 60 * 1e3;
-var HEAL_MAX_ANCHORS = 50;
 var HEAL_ANCHOR_SEARCH_OVERFETCH = 4;
 var HEAL_MAX_PROMPT_CHARS = 4e4;
 var HEAL_BATCH_SIZE = 25;
@@ -2421,6 +2509,10 @@ var MaintenanceService = class {
     if (!Number.isInteger(batchSize) || batchSize < 1) {
       throw new Error("Invalid batchSize: must be an integer >= 1");
     }
+    const bodyTruncationChars = options?.bodyTruncationChars ?? HEAL_MAX_FACT_BODY_CHARS_L3;
+    if (!Number.isInteger(bodyTruncationChars) || bodyTruncationChars < 1) {
+      throw new Error("Invalid bodyTruncationChars: must be an integer >= 1");
+    }
     const now = Date.now();
     const recheckCutoff = now - HEAL_RECHECK_MS;
     const orphanAfterDays = this.options.config?.orphanAfterDays !== void 0 ? this.options.config?.orphanAfterDays : 30;
@@ -2461,29 +2553,44 @@ var MaintenanceService = class {
         downgraded: staleDowngradedIds.length,
         deleted: orphanedIds.length,
         newFactsCreated: 0,
-        skipped: 0,
+        skipped: [],
+        degraded: [],
         remaining: counts2.eligible,
         deferred: counts2.deferred
       };
     }
-    const allTasks = await this.taskRepo.findAllPending([entityId]);
+    const allTasks = await this.taskRepo.findAllPending([entityId], HEAL_MAX_TASKS);
     const recentEvents = await this.eventRepo.getRecent(entityId, 20);
     const toPromptShape = (f) => {
       const { embedding: _embedding, embedding_blob: _blob, ...rest } = f;
       return { ...rest, tags: typeof rest.tags === "string" ? JSON.parse(rest.tags) : rest.tags };
     };
     const anchorCache = /* @__PURE__ */ new Map();
+    const degraded = [];
     const outcome = await runBatched({
       items: healCandidates,
-      buildPrompt: async (batch) => {
-        const documentAnchors = await this._selectHealAnchors(entityId, batch, anchorCache);
-        return this.promptService.buildHealPrompt(
+      buildPrompt: async (batch, attemptLevel = 0) => {
+        const documentAnchors = await this._selectHealAnchors(
+          entityId,
+          batch,
+          // Per-batch anchor cap: `batch.length * HEAL_ANCHORS_PER_CANDIDATE` (capped at
+          // HEAL_MAX_ANCHORS) right-sizes the anchor lookup so a 1-fact batch does
+          // not overfetch the same 200 keyword hits a 25-fact batch once did.
+          // buildHealPrompt applies the matching cap on its side — values must match.
+          Math.min(HEAL_MAX_ANCHORS, batch.length * HEAL_ANCHORS_PER_CANDIDATE),
+          anchorCache
+        );
+        const { prompts, degraded: batchDegraded } = await this.promptService.buildHealPrompt(
           batch.map(toPromptShape),
           documentAnchors,
           allTasks,
           recentEvents,
-          promptOverride
+          promptOverride,
+          attemptLevel,
+          bodyTruncationChars
         );
+        degraded.push(...batchDegraded);
+        return prompts;
       },
       call: (prompts) => this.options.llmProvider.generateText(prompts),
       parse: (responseText, batch) => {
@@ -2557,8 +2664,14 @@ var MaintenanceService = class {
         insertedFacts.push({ id, entity_id: entityId, title: fact.title, body: fact.body, tags: JSON.stringify(fact.tags) });
         healFactsForDedupe.push({ id, title: fact.title });
       }
+      const callErrorIds = new Set(
+        outcome.skipped.filter((s) => s.reason === "call_error").map((s) => s.item.id)
+      );
       await this.entryRepo.markHealChecked(
-        [...healCandidates.map((f) => f.id), ...insertedFacts.map((f) => f.id)],
+        [
+          ...healCandidates.map((f) => f.id).filter((id) => !callErrorIds.has(id)),
+          ...insertedFacts.map((f) => f.id)
+        ],
         entityId,
         now,
         tx
@@ -2576,6 +2689,13 @@ var MaintenanceService = class {
       await this.embeddingService.embedFact(fact);
     }
     this.searchService.evictCache(entityId);
+    const skippedIds = new Set(outcome.skipped.map(({ item }) => item.id));
+    const healedDegraded = degraded.filter((d) => !skippedIds.has(d.id));
+    for (const d of healedDegraded) {
+      console.warn(
+        `[WikiMemory] heal healed under degraded context ${entityId}/${d.id}: body truncated from ${d.originalBodyChars} to ${d.truncatedBodyChars} chars`
+      );
+    }
     let scanned = outcome.skipped.length;
     for (const batchResult of outcome.results) scanned += batchResult.batch.length;
     const allDowngraded = /* @__PURE__ */ new Set([...staleDowngradedIds, ...safeDowngraded]);
@@ -2586,7 +2706,8 @@ var MaintenanceService = class {
       downgraded: allDowngraded.size,
       deleted: allDeleted.size,
       newFactsCreated: insertedFacts.length,
-      skipped: outcome.skipped.length,
+      skipped: outcome.skipped.map(({ item, reason }) => ({ id: item.id, reason })),
+      degraded: healedDegraded,
       remaining: counts.eligible,
       deferred: counts.deferred
     };
@@ -2670,7 +2791,15 @@ var MaintenanceService = class {
       };
     }
     if (outcome.skipped.length > 0) {
-      await this.entryRepo.markOntologyChecked(outcome.skipped.map((f) => f.id), entityId, now, this.db);
+      const callErrorIds = new Set(
+        outcome.skipped.filter((s) => s.reason === "call_error").map((s) => s.item.id)
+      );
+      await this.entryRepo.markOntologyChecked(
+        outcome.skipped.filter(({ item }) => !callErrorIds.has(item.id)).map(({ item }) => item.id),
+        entityId,
+        now,
+        this.db
+      );
     }
     this.searchService.evictCache(entityId);
     const counts = await this.entryRepo.countUntypedByEntityId(entityId, recheckCutoff);
@@ -2786,7 +2915,7 @@ var MaintenanceService = class {
    * batches that reduce to the same query share one lookup. Caller-owned and
    * per-pass — see the call site in doRunHeal.
    */
-  async _selectHealAnchors(entityId, batch, cache) {
+  async _selectHealAnchors(entityId, batch, cap = HEAL_MAX_ANCHORS, cache) {
     const query = batch.map((f) => f.title).join(" ").trim();
     if (!query) return [];
     const cached = cache?.get(query);
@@ -2794,7 +2923,7 @@ var MaintenanceService = class {
     const hits = this.searchService.searchKeyword(
       query,
       [entityId],
-      HEAL_MAX_ANCHORS * HEAL_ANCHOR_SEARCH_OVERFETCH
+      cap * HEAL_ANCHOR_SEARCH_OVERFETCH
     );
     const hitIds = hits.map((h) => h.id);
     const anchors = [];
@@ -2805,7 +2934,7 @@ var MaintenanceService = class {
         const row = byId.get(id);
         if (!row) continue;
         anchors.push(row);
-        if (anchors.length >= HEAL_MAX_ANCHORS) break;
+        if (anchors.length >= cap) break;
       }
     }
     cache?.set(query, anchors);