@equationalapplications/core-llm-wiki 5.3.1 → 5.5.0

package/dist/index.js

@@ -1,7 +1,7 @@
 'use strict';
 
-var MiniSearch = require('minisearch');
 var coreOkf = require('@equationalapplications/core-okf');
+var MiniSearch = require('minisearch');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -37,7 +37,15 @@ async function setupDatabase(db, prefix) {
       embedding_blob BLOB,
       okf_type TEXT,
       ontology_checked_at INTEGER,
-      heal_checked_at INTEGER
+      heal_checked_at INTEGER,
+      lifecycle_status TEXT NOT NULL DEFAULT 'stable',
+      stale_after INTEGER,
+      generated_by TEXT,
+      last_verified_at INTEGER,
+      last_verified_by TEXT,
+      okf_sources TEXT,
+      okf_verified TEXT,
+      okf_usage_window TEXT
     );
 
     CREATE INDEX IF NOT EXISTS ${prefix}entries_entity_idx ON ${prefix}entries(entity_id);
@@ -73,7 +81,15 @@ async function setupDatabase(db, prefix) {
       updated_at INTEGER NOT NULL,
       resolved_at INTEGER,
       deleted_at INTEGER,
-      okf_type TEXT
+      okf_type TEXT,
+      lifecycle_status TEXT NOT NULL DEFAULT 'stable',
+      stale_after INTEGER,
+      generated_by TEXT,
+      last_verified_at INTEGER,
+      last_verified_by TEXT,
+      okf_sources TEXT,
+      okf_verified TEXT,
+      okf_usage_window TEXT
     );
 
     CREATE INDEX IF NOT EXISTS ${prefix}tasks_entity_idx ON ${prefix}tasks(entity_id, status);
@@ -135,6 +151,24 @@ async function setupDatabase(db, prefix) {
     CREATE INDEX IF NOT EXISTS ${prefix}outbox_created_at
       ON ${prefix}outbox (created_at);
   `);
+  await createOkfV02IndexesIfColumnsExist(db, prefix);
+}
+async function createOkfV02IndexesIfColumnsExist(db, prefix) {
+  for (const table of ["entries", "tasks"]) {
+    const cols = await db.getAllAsync(
+      `PRAGMA table_info(${prefix}${table})`
+    );
+    const colNames = new Set(cols.map((c) => c.name));
+    if (colNames.has("lifecycle_status")) {
+      await db.execAsync(`CREATE INDEX IF NOT EXISTS ${prefix}${table}_lifecycle_status_idx ON ${prefix}${table}(lifecycle_status);`);
+    }
+    if (colNames.has("stale_after")) {
+      await db.execAsync(`CREATE INDEX IF NOT EXISTS ${prefix}${table}_stale_after_idx ON ${prefix}${table}(stale_after);`);
+    }
+    if (colNames.has("last_verified_at")) {
+      await db.execAsync(`CREATE INDEX IF NOT EXISTS ${prefix}${table}_last_verified_at_idx ON ${prefix}${table}(last_verified_at);`);
+    }
+  }
 }
 
 // src/db/sqliteCodes.ts
@@ -253,6 +287,25 @@ var PrunePartialFailureError = class extends Error {
   }
 };
 var HOOK_TIMEOUT_MARKER = /* @__PURE__ */ Symbol("WikiMemoryHookTimeout");
+var WikiParseError = class extends Error {
+  constructor(message, opts) {
+    super(message);
+    this.name = "WikiParseError";
+    this.tier = opts.tier;
+    this.position = opts.position ?? null;
+    this.slice = opts.slice ?? "";
+  }
+};
+var WikiIngestEmptyError = class extends Error {
+  constructor(params) {
+    const summary = `All ${params.chunks} chunks failed for sourceRef "${params.sourceRef}"; see parseFailures for per-chunk detail`;
+    super(summary);
+    this.name = "WikiIngestEmptyError";
+    this.parseFailures = params.parseFailures;
+    this.sourceRef = params.sourceRef;
+    this.chunks = params.chunks;
+  }
+};
 
 // src/db/serializedAdapter.ts
 function isDriverError(err) {
@@ -481,6 +534,39 @@ var MIGRATIONS = [
          WHERE rn = 1;`
       );
     }
+  },
+  {
+    version: 10,
+    description: "OKF v0.2: add lifecycle_status, stale_after, generated_by, last_verified_*, okf_sources, okf_verified, okf_usage_window to entries and tasks",
+    run: async (db, prefix) => {
+      for (const table of ["entries", "tasks"]) {
+        const cols = await db.getAllAsync(
+          `PRAGMA table_info(${prefix}${table})`
+        );
+        const existing = new Set(cols.map((c) => c.name));
+        const adds = [
+          ["lifecycle_status", `ALTER TABLE ${prefix}${table} ADD COLUMN lifecycle_status TEXT NOT NULL DEFAULT 'stable'`],
+          ["stale_after", `ALTER TABLE ${prefix}${table} ADD COLUMN stale_after INTEGER`],
+          ["generated_by", `ALTER TABLE ${prefix}${table} ADD COLUMN generated_by TEXT`],
+          ["last_verified_at", `ALTER TABLE ${prefix}${table} ADD COLUMN last_verified_at INTEGER`],
+          ["last_verified_by", `ALTER TABLE ${prefix}${table} ADD COLUMN last_verified_by TEXT`],
+          ["okf_sources", `ALTER TABLE ${prefix}${table} ADD COLUMN okf_sources TEXT`],
+          ["okf_verified", `ALTER TABLE ${prefix}${table} ADD COLUMN okf_verified TEXT`],
+          ["okf_usage_window", `ALTER TABLE ${prefix}${table} ADD COLUMN okf_usage_window TEXT`]
+        ];
+        for (const [name, sql] of adds) {
+          if (!existing.has(name)) await db.execAsync(sql);
+        }
+      }
+      await db.execAsync(`
+        CREATE INDEX IF NOT EXISTS ${prefix}entries_lifecycle_status_idx ON ${prefix}entries(lifecycle_status);
+        CREATE INDEX IF NOT EXISTS ${prefix}entries_stale_after_idx ON ${prefix}entries(stale_after);
+        CREATE INDEX IF NOT EXISTS ${prefix}entries_last_verified_at_idx ON ${prefix}entries(last_verified_at);
+        CREATE INDEX IF NOT EXISTS ${prefix}tasks_lifecycle_status_idx ON ${prefix}tasks(lifecycle_status);
+        CREATE INDEX IF NOT EXISTS ${prefix}tasks_stale_after_idx ON ${prefix}tasks(stale_after);
+        CREATE INDEX IF NOT EXISTS ${prefix}tasks_last_verified_at_idx ON ${prefix}tasks(last_verified_at);
+      `);
+    }
   }
 ];
 for (let i = 1; i < MIGRATIONS.length; i++) {
@@ -507,7 +593,29 @@ var BaseRepository = class {
   }
 };
 
-// src/repositories/EntryRepository.ts
+// src/repositories/rowMappers.ts
+function parseJsonArray(s, fallback) {
+  if (Array.isArray(s)) return s;
+  if (typeof s === "string" && s.length > 0) {
+    try {
+      const p = JSON.parse(s);
+      if (Array.isArray(p)) return p;
+    } catch {
+    }
+  }
+  return fallback;
+}
+function parseJsonObject(s, fallback = null) {
+  if (s && typeof s === "object" && !Array.isArray(s)) return s;
+  if (typeof s === "string" && s.length > 0) {
+    try {
+      const p = JSON.parse(s);
+      if (p && typeof p === "object" && !Array.isArray(p)) return p;
+    } catch {
+    }
+  }
+  return fallback;
+}
 function mapRowToFact(row) {
   const tags = (() => {
     if (Array.isArray(row.tags)) return row.tags;
@@ -518,6 +626,9 @@ function mapRowToFact(row) {
     }
     return [];
   })();
+  const okf_verified = parseJsonArray(row.okf_verified, []);
+  const now = Date.now();
+  const staleAfterRaw = row.stale_after != null ? Number(row.stale_after) : null;
   return {
     id: row.id,
     entity_id: row.entity_id,
@@ -533,7 +644,19 @@ function mapRowToFact(row) {
     last_accessed_at: row.last_accessed_at === null || row.last_accessed_at === void 0 ? null : Number(row.last_accessed_at),
     deleted_at: row.deleted_at != null ? Number(row.deleted_at) : null,
     access_count: Number(row.access_count ?? 0),
-    okf_type: row.okf_type ?? null
+    okf_type: row.okf_type ?? null,
+    // OKF v0.2
+    lifecycle_status: row.lifecycle_status ?? "stable",
+    stale_after: staleAfterRaw,
+    generated_by: row.generated_by ?? null,
+    okf_sources: parseJsonArray(row.okf_sources, []),
+    okf_verified,
+    okf_usage_window: parseJsonObject(row.okf_usage_window),
+    last_verified_at: row.last_verified_at != null ? Number(row.last_verified_at) : null,
+    last_verified_by: row.last_verified_by ?? null,
+    // Spec §2.7 + §5.3: hydrate so read() consumers don't re-call the helpers.
+    isStale: coreOkf.isStaleAfter(staleAfterRaw, now),
+    trustTier: coreOkf.deriveTrustTier(okf_verified)
   };
 }
 function normalizeEmbeddingBlobValue(blob) {
@@ -589,6 +712,21 @@ var EntryRepository = class extends BaseRepository {
    * Upsert a WikiFact. Nullable fields set to null when fact value is null.
    * Returns { changes, lastInsertRowId }.
    * `tx` is REQUIRED to ensure atomic outbox staging.
+   *
+   * OKF metadata discipline (spec §2.5 + DAO checklist §8): content writes
+   * MUST NOT silently overwrite OKF metadata that a caller didn't supply. The
+   * previous CASE WHEN IS NULL guards around `lifecycle_status`, etc. were
+   * dead because the bind always supplied a non-null value (notably
+   * `fact.lifecycle_status ?? 'stable'`), so excluded.X was never NULL and
+   * an UPDATE rewrote an existing `deprecated` row to `stable`. We now omit
+   * these columns from the SET clause entirely — SQLite's ON CONFLICT UPDATE
+   * leaves untouched columns at their existing row value, which is exactly
+   * the preservation semantics we want for content writes. Callers that
+   * intentionally want to overwrite OKF metadata should use
+   * {@link upsertForImport} (always-replace semantics for that path).
+   * New-row INSERTs still bind a value so the column is populated; if the
+   * caller supplied nothing, the schema DEFAULT 'stable' applies when the
+   * bind is bound as 'stable' explicitly here.
    */
   async upsert(fact, tx) {
     const executor = this.getExecutor(tx);
@@ -596,7 +734,10 @@ var EntryRepository = class extends BaseRepository {
     const tagsJson = JSON.stringify(fact.tags);
     const embeddingBlob = this.normalizeEmbeddingBlob(fact.embedding_blob);
     const existingRow = await executor.getFirstAsync(
-      `SELECT id FROM ${this.prefix}entries WHERE id = ?`,
+      `SELECT id, lifecycle_status, stale_after, generated_by,
+              okf_sources, okf_verified, okf_usage_window,
+              last_verified_at, last_verified_by
+         FROM ${this.prefix}entries WHERE id = ?`,
       [fact.id]
     );
     const operation = fact.deleted_at ? "DELETE" : existingRow ? "UPDATE" : "INSERT";
@@ -604,8 +745,10 @@ var EntryRepository = class extends BaseRepository {
       `INSERT INTO ${this.prefix}entries (
         id, entity_id, title, body, tags, confidence, source_type,
         source_hash, source_ref, created_at, updated_at, last_accessed_at, access_count,
-        deleted_at, embedding_blob, embedding, okf_type
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        deleted_at, embedding_blob, embedding, okf_type,
+        lifecycle_status, stale_after, generated_by, last_verified_at, last_verified_by,
+        okf_sources, okf_verified, okf_usage_window
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET
         entity_id = excluded.entity_id,
         title = excluded.title,
@@ -639,15 +782,36 @@ var EntryRepository = class extends BaseRepository {
         fact.deleted_at ?? null,
         embeddingBlob ?? null,
         null,
-        fact.okf_type ?? null
+        fact.okf_type ?? null,
+        // OKF v0.2 metadata — bound for INSERT only; ON CONFLICT UPDATE
+        // preserves the existing row values (these columns are intentionally
+        // absent from the SET clause above).
+        fact.lifecycle_status ?? "stable",
+        fact.stale_after ?? null,
+        fact.generated_by ?? null,
+        fact.last_verified_at ?? null,
+        fact.last_verified_by ?? null,
+        fact.okf_sources ? JSON.stringify(fact.okf_sources) : null,
+        fact.okf_verified ? JSON.stringify(fact.okf_verified) : null,
+        fact.okf_usage_window ? JSON.stringify(fact.okf_usage_window) : null
       ]
     );
+    const persistedOkf = existingRow ? {
+      lifecycle_status: existingRow.lifecycle_status ?? "stable",
+      stale_after: existingRow.stale_after != null ? Number(existingRow.stale_after) : null,
+      generated_by: existingRow.generated_by ?? null,
+      okf_sources: parseJsonArray(existingRow.okf_sources, []),
+      okf_verified: parseJsonArray(existingRow.okf_verified, []),
+      okf_usage_window: parseJsonObject(existingRow.okf_usage_window),
+      last_verified_at: existingRow.last_verified_at != null ? Number(existingRow.last_verified_at) : null,
+      last_verified_by: existingRow.last_verified_by ?? null
+    } : null;
     await this.outbox.push({
       entityId: fact.entity_id,
       tableName: "entries",
       recordId: fact.id,
       operation,
-      payload: fact
+      payload: persistedOkf ? { ...fact, ...persistedOkf } : fact
     }, tx);
     return result;
   }
@@ -708,8 +872,10 @@ var EntryRepository = class extends BaseRepository {
       `INSERT INTO ${this.prefix}entries (
         id, entity_id, title, body, tags, confidence, source_type,
         source_hash, source_ref, created_at, updated_at, last_accessed_at, access_count,
-        deleted_at, embedding_blob, embedding, okf_type
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        deleted_at, embedding_blob, embedding, okf_type,
+        lifecycle_status, stale_after, generated_by, last_verified_at, last_verified_by,
+        okf_sources, okf_verified, okf_usage_window
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET
         entity_id = excluded.entity_id,
         title = excluded.title,
@@ -726,7 +892,15 @@ var EntryRepository = class extends BaseRepository {
         deleted_at = excluded.deleted_at,
         embedding_blob = excluded.embedding_blob,
         embedding = NULL,
-        okf_type = excluded.okf_type`,
+        okf_type = excluded.okf_type,
+        lifecycle_status = excluded.lifecycle_status,
+        stale_after = excluded.stale_after,
+        generated_by = excluded.generated_by,
+        last_verified_at = excluded.last_verified_at,
+        last_verified_by = excluded.last_verified_by,
+        okf_sources = excluded.okf_sources,
+        okf_verified = excluded.okf_verified,
+        okf_usage_window = excluded.okf_usage_window`,
       [
         fact.id,
         fact.entity_id,
@@ -744,7 +918,16 @@ var EntryRepository = class extends BaseRepository {
         fact.deleted_at ?? null,
         embeddingBlob ?? null,
         null,
-        fact.okf_type ?? null
+        fact.okf_type ?? null,
+        // Same NOT NULL DEFAULT note as in upsert above.
+        fact.lifecycle_status ?? "stable",
+        fact.stale_after ?? null,
+        fact.generated_by ?? null,
+        fact.last_verified_at ?? null,
+        fact.last_verified_by ?? null,
+        fact.okf_sources ? JSON.stringify(fact.okf_sources) : null,
+        fact.okf_verified ? JSON.stringify(fact.okf_verified) : null,
+        fact.okf_usage_window ? JSON.stringify(fact.okf_usage_window) : null
       ]
     );
     return result;
@@ -1696,9 +1879,10 @@ var SourceRefIndexRepository = class extends BaseRepository {
     return row?.source_ref ?? null;
   }
 };
-
-// src/repositories/TaskRepository.ts
 function mapRowToTask(row) {
+  const okf_verified = parseJsonArray(row.okf_verified, []);
+  const now = Date.now();
+  const staleAfterRaw = row.stale_after != null ? Number(row.stale_after) : null;
   return {
     id: row.id,
     entity_id: row.entity_id,
@@ -1709,7 +1893,19 @@ function mapRowToTask(row) {
     updated_at: Number(row.updated_at),
     resolved_at: row.resolved_at != null ? Number(row.resolved_at) : null,
     deleted_at: row.deleted_at != null ? Number(row.deleted_at) : null,
-    okf_type: row.okf_type ?? null
+    okf_type: row.okf_type ?? null,
+    // OKF v0.2
+    lifecycle_status: row.lifecycle_status ?? "stable",
+    stale_after: staleAfterRaw,
+    generated_by: row.generated_by ?? null,
+    okf_sources: parseJsonArray(row.okf_sources, []),
+    okf_verified,
+    okf_usage_window: parseJsonObject(row.okf_usage_window),
+    last_verified_at: row.last_verified_at != null ? Number(row.last_verified_at) : null,
+    last_verified_by: row.last_verified_by ?? null,
+    // Spec §2.7 + §5.3: hydrate so read() consumers don't re-call the helpers.
+    isStale: coreOkf.isStaleAfter(staleAfterRaw, now),
+    trustTier: coreOkf.deriveTrustTier(okf_verified)
   };
 }
 var TaskRepository = class extends BaseRepository {
@@ -1759,20 +1955,31 @@ var TaskRepository = class extends BaseRepository {
    * Uses ON CONFLICT(id) DO UPDATE (not INSERT OR REPLACE).
    * Stages an outbox entry in the same transaction.
    * `tx` is REQUIRED.
+   *
+   * OKF metadata (lifecycle_status, sources, etc.) is intentionally excluded
+   * from the SET clause so content writes preserve any existing row values.
+   * See {@link EntryRepository.upsert} for the rationale — the same applies
+   * symmetrically to tasks (spec §2.5). Callers that need to overwrite OKF
+   * metadata should use {@link upsertForImport}.
    */
   async upsert(task, tx, updatedAt) {
     const executor = this.getExecutor(tx);
     const now = Number.isFinite(updatedAt) ? updatedAt : Date.now();
     const existingRow = await executor.getFirstAsync(
-      `SELECT id FROM ${this.prefix}tasks WHERE id = ?`,
+      `SELECT id, lifecycle_status, stale_after, generated_by,
+              okf_sources, okf_verified, okf_usage_window,
+              last_verified_at, last_verified_by
+         FROM ${this.prefix}tasks WHERE id = ?`,
       [task.id]
     );
     const operation = task.deleted_at != null ? "DELETE" : existingRow ? "UPDATE" : "INSERT";
     await executor.runAsync(
       `INSERT INTO ${this.prefix}tasks (
         id, entity_id, description, status, priority,
-        created_at, updated_at, resolved_at, deleted_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        created_at, updated_at, resolved_at, deleted_at,
+        lifecycle_status, stale_after, generated_by, last_verified_at, last_verified_by,
+        okf_sources, okf_verified, okf_usage_window
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET
         entity_id = excluded.entity_id,
         description = excluded.description,
@@ -1791,16 +1998,37 @@ var TaskRepository = class extends BaseRepository {
         now,
         // updated_at set by repo or import override
         task.resolved_at ?? null,
-        task.deleted_at ?? null
+        task.deleted_at ?? null,
+        // OKF v0.2 metadata — bound for INSERT only; ON CONFLICT UPDATE
+        // preserves the existing row values (these columns are intentionally
+        // absent from the SET clause above).
+        task.lifecycle_status ?? "stable",
+        task.stale_after ?? null,
+        task.generated_by ?? null,
+        task.last_verified_at ?? null,
+        task.last_verified_by ?? null,
+        task.okf_sources ? JSON.stringify(task.okf_sources) : null,
+        task.okf_verified ? JSON.stringify(task.okf_verified) : null,
+        task.okf_usage_window ? JSON.stringify(task.okf_usage_window) : null
       ]
     );
+    const persistedOkf = existingRow ? {
+      lifecycle_status: existingRow.lifecycle_status ?? "stable",
+      stale_after: existingRow.stale_after != null ? Number(existingRow.stale_after) : null,
+      generated_by: existingRow.generated_by ?? null,
+      okf_sources: parseJsonArray(existingRow.okf_sources, []),
+      okf_verified: parseJsonArray(existingRow.okf_verified, []),
+      okf_usage_window: parseJsonObject(existingRow.okf_usage_window),
+      last_verified_at: existingRow.last_verified_at != null ? Number(existingRow.last_verified_at) : null,
+      last_verified_by: existingRow.last_verified_by ?? null
+    } : null;
     await this.outbox.push(
       {
         entityId: task.entity_id,
         tableName: "tasks",
         recordId: task.id,
         operation,
-        payload: task
+        payload: persistedOkf ? { ...task, ...persistedOkf } : task
       },
       tx
     );
@@ -1811,8 +2039,10 @@ var TaskRepository = class extends BaseRepository {
     await executor.runAsync(
       `INSERT INTO ${this.prefix}tasks (
         id, entity_id, description, status, priority,
-        created_at, updated_at, resolved_at, deleted_at, okf_type
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        created_at, updated_at, resolved_at, deleted_at, okf_type,
+        lifecycle_status, stale_after, generated_by, last_verified_at, last_verified_by,
+        okf_sources, okf_verified, okf_usage_window
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET
         entity_id = excluded.entity_id,
         description = excluded.description,
@@ -1821,7 +2051,15 @@ var TaskRepository = class extends BaseRepository {
         updated_at = excluded.updated_at,
         resolved_at = excluded.resolved_at,
         deleted_at = excluded.deleted_at,
-        okf_type = excluded.okf_type`,
+        okf_type = excluded.okf_type,
+        lifecycle_status = excluded.lifecycle_status,
+        stale_after = excluded.stale_after,
+        generated_by = excluded.generated_by,
+        last_verified_at = excluded.last_verified_at,
+        last_verified_by = excluded.last_verified_by,
+        okf_sources = excluded.okf_sources,
+        okf_verified = excluded.okf_verified,
+        okf_usage_window = excluded.okf_usage_window`,
       [
         task.id,
         task.entity_id,
@@ -1832,7 +2070,15 @@ var TaskRepository = class extends BaseRepository {
         now,
         task.resolved_at ?? null,
         task.deleted_at ?? null,
-        task.okf_type ?? null
+        task.okf_type ?? null,
+        task.lifecycle_status ?? "stable",
+        task.stale_after ?? null,
+        task.generated_by ?? null,
+        task.last_verified_at ?? null,
+        task.last_verified_by ?? null,
+        task.okf_sources ? JSON.stringify(task.okf_sources) : null,
+        task.okf_verified ? JSON.stringify(task.okf_verified) : null,
+        task.okf_usage_window ? JSON.stringify(task.okf_usage_window) : null
       ]
     );
   }
@@ -3190,24 +3436,67 @@ var JobManager = class {
 };
 
 // src/utils/pure.ts
+var MAX_REPAIR_CANDIDATES = 5;
+function throwNoJsonFound(text, start) {
+  throw new WikiParseError(
+    "No JSON object/array found in LLM response",
+    { tier: "strict", position: start, slice: text }
+  );
+}
 function parseJsonResponse(text) {
   const firstBrace = text.indexOf("{");
   const firstBracket = text.indexOf("[");
   let start;
   let openChar;
-  let closeChar;
   const useBrace = firstBrace !== -1 && (firstBracket === -1 || firstBrace < firstBracket);
   if (useBrace) {
     start = firstBrace;
     openChar = "{";
-    closeChar = "}";
   } else if (firstBracket !== -1) {
     start = firstBracket;
     openChar = "[";
-    closeChar = "]";
   } else {
-    throw new SyntaxError("No JSON object/array found in LLM response");
+    throwNoJsonFound(text, null);
+  }
+  const slice = scanJsonSlice(text, start, openChar);
+  if (slice !== null) {
+    try {
+      return JSON.parse(slice);
+    } catch {
+    }
+  }
+  const repairOdd = containerAwareRepair(text, start, false);
+  if (repairOdd.success !== null && !repairOdd.ambiguous) {
+    return repairOdd.success;
+  }
+  const repairEven = containerAwareRepair(text, start, true);
+  if (repairOdd.success !== null && repairEven.success !== null) {
+    const pick = repairEven.escapes < repairOdd.escapes ? repairEven : repairOdd;
+    return pick.success;
+  }
+  if (repairOdd.success !== null) {
+    return repairOdd.success;
+  }
+  if (repairEven.success !== null) {
+    return repairEven.success;
   }
+  const repair = repairEven.failed !== null ? repairEven : repairOdd;
+  if (repair.failed !== null) {
+    throw new WikiParseError(
+      `Repair produced a candidate but JSON.parse rejected it: ${repair.failed.message}`,
+      { tier: "repair", position: repair.failed.position, slice: repair.failed.candidate }
+    );
+  }
+  if (slice === null) {
+    throwNoJsonFound(text, start);
+  }
+  throw new WikiParseError(
+    "No parsable JSON candidate found",
+    { tier: "all", position: start, slice: text }
+  );
+}
+function scanJsonSlice(text, start, openChar) {
+  const closeChar = openChar === "{" ? "}" : "]";
   let depth = 0;
   let inString = false;
   let escape = false;
@@ -3239,8 +3528,193 @@ function parseJsonResponse(text) {
       }
     }
   }
-  if (end === -1) throw new SyntaxError("No JSON object/array found in LLM response");
-  return JSON.parse(text.slice(start, end + 1));
+  if (end === -1) return null;
+  return safeSlice(text, start, end + 1);
+}
+function containerAwareRepair(text, start, closeOnEvenParity) {
+  const stack = [];
+  let inString = false;
+  let stringRole = null;
+  let escape = false;
+  let i = start;
+  let out = "";
+  let bareQuoteCount = 0;
+  let bestFailed = null;
+  let escapes = 0;
+  let ambiguous = false;
+  let bestSuccess = null;
+  let attempts = 0;
+  function tryEmitCandidate(candidate) {
+    attempts++;
+    try {
+      bestSuccess = JSON.parse(candidate);
+      return true;
+    } catch (err) {
+      if (bestFailed === null) {
+        bestFailed = {
+          candidate,
+          position: extractParsePosition(err),
+          message: safeErrorToString(err)
+        };
+      }
+      return false;
+    }
+  }
+  while (i < text.length) {
+    const ch = text[i];
+    if (stack.length === 0 && !inString) {
+      if (ch === "{" || ch === "[") {
+        stack.push({ container: ch === "{" ? "object" : "array", expectKey: true });
+        out += ch;
+      }
+      i++;
+      continue;
+    }
+    if (escape) {
+      out += ch;
+      escape = false;
+      i++;
+      continue;
+    }
+    if (inString && ch === "\\") {
+      out += ch;
+      escape = true;
+      i++;
+      continue;
+    }
+    if (inString) {
+      const code = ch.charCodeAt(0);
+      if (code < 32) {
+        out += controlCharEscape(code);
+        i++;
+        continue;
+      }
+    }
+    if (ch === '"') {
+      let j = i + 1;
+      while (j < text.length && (text[j] === " " || text[j] === "	" || text[j] === "\n" || text[j] === "\r")) {
+        j++;
+      }
+      const next = j < text.length ? text[j] : "";
+      if (!inString) {
+        if (next === "}" || next === "]") {
+          if (j > i + 1) out += text.slice(i + 1, j);
+          out += next;
+          i = j + 1;
+          stack.pop();
+          if (stack.length === 0) {
+            if (tryEmitCandidate(out)) return { success: bestSuccess, failed: bestFailed, escapes, ambiguous };
+            if (attempts >= MAX_REPAIR_CANDIDATES) break;
+            out = "";
+          }
+          continue;
+        }
+        const top = stack[stack.length - 1];
+        stringRole = top?.container === "object" && top.expectKey ? "key" : "value";
+        out += ch;
+        inString = true;
+        i++;
+        continue;
+      }
+      const commaOnly = next === ",";
+      const isKeyClose = stringRole === "key" && (next === ":" || next === '"' && j + 1 < text.length && text[j + 1] === ":");
+      const isValueClose = !commaOnly && (next === "," || next === "}" || next === "]");
+      if (commaOnly && bareQuoteCount > 0) ambiguous = true;
+      const shouldCommaClose = commaOnly && (bareQuoteCount === 0 || (closeOnEvenParity ? bareQuoteCount % 2 === 0 : bareQuoteCount % 2 === 1));
+      const isClosing = isKeyClose || isValueClose || shouldCommaClose;
+      if (isClosing) {
+        out += ch;
+        inString = false;
+        const topFrame = stack[stack.length - 1];
+        if (topFrame && topFrame.container === "object") {
+          topFrame.expectKey = stringRole === "value";
+        }
+        stringRole = null;
+        bareQuoteCount = 0;
+        i++;
+        continue;
+      }
+      out += "\\" + ch;
+      bareQuoteCount++;
+      escapes++;
+      i++;
+      continue;
+    }
+    if (!inString && (ch === "{" || ch === "[")) {
+      stack.push({ container: ch === "{" ? "object" : "array", expectKey: true });
+      out += ch;
+      i++;
+      continue;
+    }
+    if (!inString && ch === ",") {
+      const topFrame = stack[stack.length - 1];
+      if (topFrame && topFrame.container === "object") {
+        topFrame.expectKey = true;
+      }
+      out += ch;
+      i++;
+      continue;
+    }
+    if (!inString && (ch === "}" || ch === "]")) {
+      out += ch;
+      stack.pop();
+      if (stack.length === 0) {
+        if (tryEmitCandidate(out)) return { success: bestSuccess, failed: bestFailed, escapes, ambiguous };
+        if (attempts >= MAX_REPAIR_CANDIDATES) break;
+        out = "";
+      }
+      i++;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return { success: null, failed: bestFailed, escapes, ambiguous };
+}
+function controlCharEscape(code) {
+  switch (code) {
+    case 10:
+      return "\\n";
+    case 9:
+      return "\\t";
+    case 13:
+      return "\\r";
+    case 8:
+      return "\\b";
+    case 12:
+      return "\\f";
+    default:
+      return "\\u" + code.toString(16).padStart(4, "0");
+  }
+}
+function extractParsePosition(err) {
+  const match = /position\s+(\d+)/.exec(safeErrorToString(err));
+  return match ? Number(match[1]) : null;
+}
+function safeErrorToString(e) {
+  if (e instanceof Error) {
+    const msg = readErrorField(e, "message");
+    if (typeof msg === "string" && msg.length > 0) return msg;
+    const name = readErrorField(e, "name");
+    if (typeof name === "string" && name.length > 0) return name;
+    return "[Error]";
+  }
+  try {
+    return String(e);
+  } catch {
+    try {
+      return Object.prototype.toString.call(e);
+    } catch {
+      return "[unstringifiable error]";
+    }
+  }
+}
+function readErrorField(e, key) {
+  try {
+    return e[key];
+  } catch {
+    return void 0;
+  }
 }
 function sanitizeRankerError(err, sanitizeRankerErrors) {
   if (sanitizeRankerErrors === false) {
@@ -3425,7 +3899,7 @@ Return ONLY a valid JSON object matching this schema:
 {
   "facts": [{ "title": "string (max 80 chars)", "body": "string (max 800 chars)", "tags": ["string"], "confidence": "certain|inferred|tentative" }]
 }
-Extract verbatim factual content. Do not return markdown, just raw JSON.`;
+Extract verbatim factual content. JSON escaping rules: every literal " character in the source must be escaped as \\" inside any JSON string body, and every literal newline as \\n. Source prose containing quotes (e.g. a worked example with "...") must still be reproduced exactly \u2014 re-escape, do not omit. Do not return markdown, just raw JSON.`;
 var ONTOLOGY_BACKFILL_SYSTEM_PROMPT = `You are a knowledge classification agent. You will receive existing memory facts that currently have no ontology type. For each input fact { "id", "title", "body", "tags" }, assign the best matching okf_type from the ontology manifest and optionally propose edges to related facts by title.
 Return ONLY a valid JSON object matching this schema:
 {
@@ -3434,7 +3908,7 @@ 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.
-Do not return markdown, just raw JSON.`;
+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/services/PromptService.ts
 var PromptService = class {
@@ -3547,6 +4021,16 @@ var DEFAULT_MAX_CHUNK_LENGTH = 12e3;
 var DEFAULT_CHUNK_OVERLAP = 400;
 
 // src/services/IngestionService.ts
+function zeroChunkResult(duplicateOf) {
+  const result = {
+    truncated: false,
+    chunks: 0,
+    ingestedChunks: 0,
+    failedChunks: 0
+  };
+  if (duplicateOf !== void 0) result.duplicateOf = duplicateOf;
+  return result;
+}
 var IngestionService = class {
   constructor(db, prefix, options, entryRepo, sourceRefIndexRepo, metadataRepo, edgeRepo, searchService, jobManager, embeddingService, promptService, ontologyService) {
     this.db = db;
@@ -3587,113 +4071,110 @@ var IngestionService = class {
           if (onDuplicateHash === "throw") {
             throw new WikiDuplicateHashError({ canonical, sourceHash, entityId });
           }
-          return { truncated: false, chunks: 0, duplicateOf: canonical };
+          return zeroChunkResult(canonical);
         }
       }
       const { chunks, truncated } = chunkText(params.documentChunk, maxChunkLength, chunkOverlap);
-      if (chunks.length === 0) return { truncated: false, chunks: 0 };
+      if (chunks.length === 0) return zeroChunkResult();
+      const ontologyContext = await this.ontologyService?.buildPromptContext(entityId) ?? null;
       const chunkResults = await withConcurrency(
-        chunks.map((chunk) => async () => {
-          const ontologyContext = await this.ontologyService?.buildPromptContext(entityId) ?? null;
+        chunks.map((chunk, chunkIndex) => async () => {
           const { systemPrompt, userPrompt } = this.promptService.buildIngestPrompt(
             chunk,
             params.promptOverride,
             ontologyContext
           );
-          const responseText = await this.options.llmProvider.generateText({ systemPrompt, userPrompt });
-          const result = parseJsonResponse(responseText);
-          return {
-            facts: (Array.isArray(result.facts) ? result.facts : []).map(validateFact).filter((f) => f !== null),
-            ontology_updates: result.ontology_updates
-          };
+          try {
+            const responseText = await this.options.llmProvider.generateText({ systemPrompt, userPrompt });
+            const result2 = parseJsonResponse(responseText);
+            return {
+              status: "ok",
+              facts: (Array.isArray(result2.facts) ? result2.facts : []).map(validateFact).filter((f) => f !== null),
+              ontology_updates: result2.ontology_updates
+            };
+          } catch (e) {
+            const failure = e instanceof WikiParseError ? {
+              chunkIndex,
+              sourceRef,
+              source: "parse",
+              tier: e.tier,
+              position: e.position,
+              message: e.message
+            } : {
+              chunkIndex,
+              sourceRef,
+              source: "llm",
+              // `safeErrorToString` is a non-throwing coercion: an LLM
+              // provider may reject with a non-Error value, and even
+              // `String(e)` itself can throw when `e.toString()` throws.
+              // Letting such an exception escape this catch would cause
+              // `withConcurrency` to reject, discarding every sibling
+              // chunk's results — the exact failure mode this per-chunk
+              // try/catch exists to prevent. Keeping the value in the
+              // `ChunkFailure` preserves the typed diagnostic for
+              // callers (see parseFailures) without unwinding the loop.
+              position: null,
+              message: safeErrorToString(e)
+            };
+            const total = chunks.length;
+            const tags = [];
+            if (failure.tier) tags.push(`tier=${failure.tier}`);
+            if (failure.position !== null) tags.push(`position=${failure.position}`);
+            const tagsSuffix = tags.length > 0 ? `; ${tags.join(" ")}` : "";
+            console.warn(
+              `[WikiMemory] ingest chunk ${chunkIndex + 1}/${total} ${failure.source} failed (sourceRef=${sourceRef}${tagsSuffix})`
+            );
+            return { status: "failed", error: failure };
+          }
         }),
         chunkConcurrency
       );
+      let ingestedChunks = 0;
+      let failedChunks = 0;
+      const failures = [];
       const seen = /* @__PURE__ */ new Set();
       const orderedChunkFacts = [];
-      for (const chunkResult of chunkResults) {
+      for (const slot of chunkResults) {
+        if (slot.status === "failed") {
+          failedChunks++;
+          failures.push(slot.error);
+          continue;
+        }
+        ingestedChunks++;
         const dedupedFacts = [];
-        for (const fact of chunkResult.facts) {
+        for (const fact of slot.facts) {
           const normalizedTitle = normalizeTitleKey(fact.title);
           if (!seen.has(normalizedTitle)) {
             seen.add(normalizedTitle);
             dedupedFacts.push(fact);
           }
         }
-        orderedChunkFacts.push({ facts: dedupedFacts, ontology_updates: chunkResult.ontology_updates });
+        orderedChunkFacts.push({ facts: dedupedFacts, ontology_updates: slot.ontology_updates });
+      }
+      if (failedChunks === chunks.length) {
+        throw new WikiIngestEmptyError({
+          parseFailures: failures,
+          sourceRef,
+          chunks: chunks.length
+        });
       }
-      const now = Date.now();
       const insertedFacts = [];
       const deletedSourceFactIds = [];
       try {
-        await this.db.withTransactionAsync(async (tx) => {
-          deletedSourceFactIds.push(...await this.entryRepo.findIdsBySource(entityId, sourceRef, null, tx, false));
-          const titleIndex = /* @__PURE__ */ new Map();
-          const existingFacts = await this.entryRepo.findRecentByEntityId(entityId, 500, tx, sourceRef);
-          for (const existing of existingFacts) {
-            titleIndex.set(normalizeTitleKey(existing.title), {
-              id: existing.id,
-              okf_type: existing.okf_type ?? null
-            });
-          }
-          let ontologyState = await this.ontologyService?.getEffectiveState(entityId, tx) ?? { mode: "off", manifest: { node_types: [], edge_types: [] } };
-          let { mode, manifest } = ontologyState;
-          const hostNodes = [];
-          const rawEdgeRequests = [];
-          for (const { facts, ontology_updates } of orderedChunkFacts) {
-            if (mode === "emergent" && ontology_updates && this.ontologyService) {
-              manifest = await this.ontologyService.mergeEmergentUpdates(entityId, ontology_updates, tx);
-              ontologyState = await this.ontologyService.getEffectiveState(entityId, tx);
-              mode = ontologyState.mode;
-            }
-            for (const fact of facts) {
-              const ontologyFact = fact;
-              const normalized = this.ontologyService?.validateAndNormalizeFact(ontologyFact, manifest, { strict: false }) ?? { okf_type: null, edges: [] };
-              const id = generateId("fact_");
-              hostNodes.push({
-                id,
-                type: ontologyFact.okf_type ?? "",
-                title: fact.title,
-                body: fact.body,
-                // Forward the LLM-extracted tags/confidence through the
-                // extracted-shape upsertGraphCore path so the entries row
-                // stores them (search filterability, heal-candidate
-                // selection, runReembed embedding-text signal). The public
-                // WikiMemory.upsertGraph API doesn't accept tags/confidence
-                // — host-supplied deterministic nodes default to [] and
-                // 'certain' as documented.
-                tags: fact.tags,
-                confidence: fact.confidence
-              });
-              insertedFacts.push({ id, entity_id: entityId, title: fact.title, body: fact.body, tags: JSON.stringify(fact.tags) });
-              titleIndex.set(normalizeTitleKey(fact.title), { id, okf_type: normalized.okf_type });
-              if (normalized.edges.length > 0) {
-                rawEdgeRequests.push({ sourceId: id, sourceType: normalized.okf_type, edges: normalized.edges });
-              }
-            }
-          }
-          const hostEdges = [];
-          for (const req of rawEdgeRequests) {
-            const resolved = this.ontologyService?.resolveEdges(
-              entityId,
-              req.sourceId,
-              req.sourceType,
-              req.edges,
-              manifest,
-              titleIndex,
-              now
-            ) ?? [];
-            for (const e of resolved) {
-              hostEdges.push({ type: e.edge_type, sourceId: e.source_id, targetId: e.target_id });
-            }
-          }
-          await this.upsertGraphCore(
-            entityId,
-            { sourceRef, sourceHash, nodes: hostNodes, edges: hostEdges },
-            tx,
-            { strict: false }
-          );
-        });
+        if (failedChunks === 0) {
+          const fullResult = await this.db.withTransactionAsync(async (tx) => {
+            return await this.runFullUpsertGraph(entityId, sourceRef, sourceHash, orderedChunkFacts, tx);
+          });
+          deletedSourceFactIds.push(...fullResult.deletedSourceFactIds);
+          insertedFacts.push(...fullResult.insertedFacts);
+        } else {
+          const partialResult = await this.db.withTransactionAsync(async (tx) => {
+            const flat = [];
+            for (const slot of orderedChunkFacts) flat.push(...slot.facts);
+            return await this.appendPartialFacts(entityId, sourceRef, flat, tx);
+          });
+          insertedFacts.push(...partialResult.insertedDescriptors);
+        }
       } catch (err) {
         const sqliteCode = err instanceof WikiTransactionError ? err.sqliteErrorCode : extractSqliteCode(err);
         if (sqliteCode !== "SQLITE_CONSTRAINT_UNIQUE") throw err;
@@ -3702,22 +4183,31 @@ var IngestionService = class {
         if (onDuplicateHash === "throw" || onDuplicateHash === "ingest") {
           throw new WikiDuplicateHashError({ canonical, sourceHash, entityId });
         }
-        return { truncated: false, chunks: 0, duplicateOf: canonical };
+        return zeroChunkResult(canonical);
       }
       await this.searchService.sync(entityId);
-      const uniqueDeletedSourceFactIds = Array.from(new Set(deletedSourceFactIds));
-      for (const factId of uniqueDeletedSourceFactIds) {
-        try {
-          await this.embeddingService.notifyEmbeddingPersisted(entityId, factId, null);
-        } catch (hookErr) {
-          console.warn(`[WikiMemory] onEmbeddingPersisted hook failed during ingest for ${factId}:`, hookErr);
+      if (failedChunks === 0) {
+        const uniqueDeletedSourceFactIds = Array.from(new Set(deletedSourceFactIds));
+        for (const factId of uniqueDeletedSourceFactIds) {
+          try {
+            await this.embeddingService.notifyEmbeddingPersisted(entityId, factId, null);
+          } catch (hookErr) {
+            console.warn(`[WikiMemory] onEmbeddingPersisted hook failed during ingest for ${factId}:`, hookErr);
+          }
         }
       }
       for (const fact of insertedFacts) {
         await this.embeddingService.embedFact(fact);
       }
       this.searchService.evictCache(entityId);
-      return { truncated, chunks: chunks.length };
+      const result = {
+        truncated,
+        chunks: chunks.length,
+        ingestedChunks,
+        failedChunks
+      };
+      if (failedChunks > 0) result.parseFailures = failures;
+      return result;
     } finally {
       releaseIngestLocks();
     }
@@ -3842,6 +4332,156 @@ var IngestionService = class {
       superseded: deletedFactIds.length + deletedEdgeCount
     };
   }
+  /**
+   * Full supersession + ownership path: identical to the pre-issue-#92 behavior
+   * for the happy path. Called from the `failedChunks === 0` branch of
+   * `ingestDocument`. Runs INSIDE the caller's tx.
+   *
+   * Returns `{ deletedSourceFactIds, insertedFacts }` so the caller can fire
+   * post-commit hooks (embedding lifecycle) AFTER the transaction commits.
+   * On the partial path the caller never invokes this method; the empty
+   * arrays stay empty.
+   */
+  async runFullUpsertGraph(entityId, sourceRef, sourceHash, orderedChunkFacts, tx) {
+    const deletedSourceFactIds = [];
+    const insertedFacts = [];
+    deletedSourceFactIds.push(...await this.entryRepo.findIdsBySource(entityId, sourceRef, null, tx, false));
+    const titleIndex = /* @__PURE__ */ new Map();
+    const existingFacts = await this.entryRepo.findRecentByEntityId(entityId, 500, tx, sourceRef);
+    for (const existing of existingFacts) {
+      titleIndex.set(normalizeTitleKey(existing.title), {
+        id: existing.id,
+        okf_type: existing.okf_type ?? null
+      });
+    }
+    let ontologyState = await this.ontologyService?.getEffectiveState(entityId, tx) ?? { mode: "off", manifest: { node_types: [], edge_types: [] } };
+    let { mode, manifest } = ontologyState;
+    const hostNodes = [];
+    const rawEdgeRequests = [];
+    const now = Date.now();
+    for (const { facts, ontology_updates } of orderedChunkFacts) {
+      if (mode === "emergent" && ontology_updates && this.ontologyService) {
+        manifest = await this.ontologyService.mergeEmergentUpdates(entityId, ontology_updates, tx);
+        ontologyState = await this.ontologyService.getEffectiveState(entityId, tx);
+        mode = ontologyState.mode;
+      }
+      for (const fact of facts) {
+        const ontologyFact = fact;
+        const normalized = this.ontologyService?.validateAndNormalizeFact(ontologyFact, manifest, { strict: false }) ?? { okf_type: null, edges: [] };
+        const id = generateId("fact_");
+        hostNodes.push({
+          id,
+          type: ontologyFact.okf_type ?? "",
+          title: fact.title,
+          body: fact.body,
+          // Forward the LLM-extracted tags/confidence through the
+          // extracted-shape upsertGraphCore path so the entries row
+          // stores them (search filterability, heal-candidate
+          // selection, runReembed embedding-text signal). The public
+          // WikiMemory.upsertGraph API doesn't accept tags/confidence
+          // — host-supplied deterministic nodes default to [] and
+          // 'certain' as documented.
+          tags: fact.tags,
+          confidence: fact.confidence
+        });
+        insertedFacts.push({ id, entity_id: entityId, title: fact.title, body: fact.body, tags: JSON.stringify(fact.tags) });
+        titleIndex.set(normalizeTitleKey(fact.title), { id, okf_type: normalized.okf_type });
+        if (normalized.edges.length > 0) {
+          rawEdgeRequests.push({ sourceId: id, sourceType: normalized.okf_type, edges: normalized.edges });
+        }
+      }
+    }
+    const hostEdges = [];
+    for (const req of rawEdgeRequests) {
+      const resolved = this.ontologyService?.resolveEdges(
+        entityId,
+        req.sourceId,
+        req.sourceType,
+        req.edges,
+        manifest,
+        titleIndex,
+        now
+      ) ?? [];
+      for (const e of resolved) {
+        hostEdges.push({ type: e.edge_type, sourceId: e.source_id, targetId: e.target_id });
+      }
+    }
+    await this.upsertGraphCore(
+      entityId,
+      { sourceRef, sourceHash, nodes: hostNodes, edges: hostEdges },
+      tx,
+      { strict: false }
+    );
+    return { deletedSourceFactIds, insertedFacts };
+  }
+  /**
+   * Partial-commit path for `ingestDocument`. Inserts ONLY facts whose
+   * normalized title is not already in the live set for this (entityId,
+   * sourceRef). Does NOT call `entryRepo.softDeleteBySource` (no
+   * supersession) and does NOT call `sourceRefIndexRepo.upsert` (no
+   * ownership). Edges are NOT resolved on this path (no ontology-context
+   * build, no `resolveEdges`, no `mergeEmergentUpdates`). Stale edges from
+   * prior attempts are recovered on the next full run's supersession.
+   *
+   * Source-hash is stored as NULL on partial rows. `findLatestSourceHash`
+   * reads from the most recently updated live row for the sourceRef, so
+   * storing the incoming hash here would cause `hasChanged` to return
+   * `false` on a same-hash retry — the failed chunks would never get a
+   * second chance. With NULL, a retry sees `storedHash === null`, `hasChanged`
+   * returns `true`, and the partial commit's sibling rows remain live
+   * (deduped, not superseded) for the next attempt to extend.
+   *
+   * Runs INSIDE the caller's `tx`. Does not open a nested transaction.
+   * Returns `{ inserted, skippedDuplicate }` for observability.
+   */
+  async appendPartialFacts(entityId, sourceRef, dedupedFacts, tx) {
+    const liveIds = await this.entryRepo.findIdsBySource(entityId, sourceRef, null, tx, false);
+    const liveFacts = liveIds.length === 0 ? [] : await this.entryRepo.findByIds(liveIds, void 0, tx);
+    const liveTitles = new Set(liveFacts.map((f) => normalizeTitleKey(f.title)));
+    let inserted = 0;
+    let skippedDuplicate = 0;
+    const now = Date.now();
+    const insertedDescriptors = [];
+    for (const fact of dedupedFacts) {
+      const normalizedTitle = normalizeTitleKey(fact.title);
+      if (liveTitles.has(normalizedTitle)) {
+        skippedDuplicate++;
+        continue;
+      }
+      liveTitles.add(normalizedTitle);
+      const id = generateId("fact_");
+      const wikiFact = {
+        id,
+        entity_id: entityId,
+        title: fact.title,
+        body: fact.body,
+        tags: fact.tags,
+        confidence: fact.confidence,
+        source_type: "immutable_document",
+        // source_hash: null on partial rows — see method docstring. The
+        // full path stamps the actual hash; partial rows stay hash-less so
+        // `hasChanged` keeps returning true for retries.
+        source_hash: null,
+        source_ref: sourceRef,
+        created_at: now,
+        updated_at: now,
+        last_accessed_at: null,
+        access_count: 0,
+        deleted_at: null,
+        okf_type: null
+      };
+      await this.entryRepo.upsert(wikiFact, tx);
+      insertedDescriptors.push({
+        id,
+        entity_id: entityId,
+        title: fact.title,
+        body: fact.body,
+        tags: JSON.stringify(fact.tags)
+      });
+      inserted++;
+    }
+    return { inserted, skippedDuplicate, insertedDescriptors };
+  }
 };
 
 // src/services/BoundedLlmCall.ts
@@ -3962,6 +4602,25 @@ var HEAL_ANCHOR_SEARCH_OVERFETCH = 4;
 var HEAL_MAX_PROMPT_CHARS = 4e4;
 var HEAL_BATCH_SIZE = 25;
 var HEAL_RECHECK_MS = 7 * 24 * 60 * 60 * 1e3;
+var SKIP_ERROR_LOG_CHARS = 4096;
+var formatSkipError = (err) => {
+  let base;
+  if (err instanceof Error || typeof err !== "object" && typeof err !== "function") {
+    base = safeErrorToString(err);
+  } else {
+    try {
+      const json = JSON.stringify(err);
+      base = typeof json === "string" ? json : safeErrorToString(err);
+    } catch {
+      base = safeErrorToString(err);
+    }
+  }
+  if (base.length > SKIP_ERROR_LOG_CHARS) {
+    const truncated = safeSlice(base, 0, SKIP_ERROR_LOG_CHARS);
+    return `${truncated}\u2026[+${base.length - SKIP_ERROR_LOG_CHARS} chars truncated]`;
+  }
+  return base;
+};
 var MaintenanceService = class {
   constructor(db, prefix, options, entryRepo, sourceRefIndexRepo, taskRepo, eventRepo, metadataRepo, searchService, jobManager, embeddingService, promptService, ontologyService) {
     this.db = db;
@@ -4442,8 +5101,7 @@ var MaintenanceService = class {
       maxPromptChars: HEAL_MAX_PROMPT_CHARS,
       onSkip: (fact, err) => {
         console.warn(
-          `[WikiMemory] heal skipped ${entityId}/${fact.id}: response could not be bounded`,
-          err
+          `[WikiMemory] heal skipped ${entityId}/${fact.id}: response could not be bounded: ${formatSkipError(err)}`
         );
       }
     });
@@ -4581,8 +5239,7 @@ var MaintenanceService = class {
       maxPromptChars: ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS,
       onSkip: (fact, err) => {
         console.warn(
-          `[WikiMemory] ontology backfill skipped ${entityId}/${fact.id}: response could not be bounded`,
-          err
+          `[WikiMemory] ontology backfill skipped ${entityId}/${fact.id}: response could not be bounded: ${formatSkipError(err)}`
         );
       }
     });
@@ -4760,8 +5417,6 @@ var MaintenanceService = class {
     return sanitizeRankerError(err, this.options.sanitizeRankerErrors);
   }
 };
-
-// src/services/ImportExportService.ts
 var MAX_EMBEDDING_BLOB_BYTES = 32 * 1024;
 var IMPORT_TITLE_MAX = 500;
 var IMPORT_BODY_MAX = 8e3;
@@ -4981,7 +5636,23 @@ var ImportExportService = class {
           access_count: fact.access_count,
           deleted_at: fact.deleted_at,
           embedding_blob: blobData ?? void 0,
-          okf_type: fact.okf_type ?? null
+          okf_type: fact.okf_type ?? null,
+          // OKF v0.2 — forwarded as-is; parseOkfBundle / the caller is responsible for
+          // populating these per spec, importDump does not derive or validate them.
+          lifecycle_status: fact.lifecycle_status ?? "stable",
+          stale_after: fact.stale_after ?? null,
+          generated_by: fact.generated_by ?? null,
+          okf_sources: fact.okf_sources ?? [],
+          okf_verified: fact.okf_verified ?? [],
+          okf_usage_window: fact.okf_usage_window ?? null,
+          // last_verified_at/_by are DERIVED mirrors of `okf_verified` per spec
+          // §5.3. Recomputing here (instead of trusting the payload field) closes
+          // the invariant that a raw importDump cannot carry a
+          // last_verified_by that contradicts its own okf_verified list.
+          ...(() => {
+            const latest = coreOkf.latestVerified(fact.okf_verified ?? [], Date.now());
+            return { last_verified_at: latest?.at ?? null, last_verified_by: latest?.by ?? null };
+          })()
         };
         await this.entryRepo.upsertForImport(factObj, tx);
         if (blobData != null) {
@@ -5031,7 +5702,19 @@ var ImportExportService = class {
             updated_at: safeUpdatedAt,
             resolved_at: task.resolved_at,
             deleted_at: task.deleted_at,
-            okf_type: task.okf_type ?? null
+            okf_type: task.okf_type ?? null,
+            // OKF v0.2
+            lifecycle_status: task.lifecycle_status ?? "stable",
+            stale_after: task.stale_after ?? null,
+            generated_by: task.generated_by ?? null,
+            okf_sources: task.okf_sources ?? [],
+            okf_verified: task.okf_verified ?? [],
+            okf_usage_window: task.okf_usage_window ?? null,
+            // Derived mirrors — see fact branch above; same invariant.
+            ...(() => {
+              const latest = coreOkf.latestVerified(task.okf_verified ?? [], Date.now());
+              return { last_verified_at: latest?.at ?? null, last_verified_by: latest?.by ?? null };
+            })()
           },
           tx,
           safeUpdatedAt
@@ -6157,6 +6840,164 @@ var GraphTraversalService = class {
     return { nodes, edges: filteredEdges };
   }
 };
+var OkfTrustWritesRepository = class {
+  constructor(db, prefix) {
+    this.db = db;
+    this.prefix = prefix;
+  }
+  getExecutor(tx) {
+    return tx ?? this.db;
+  }
+  /**
+   * Append one or more verification events to a fact's `okf_verified` JSON
+   * array, atomically, in a single SQL statement.
+   *
+   * The implementation uses json_each over the existing array UNION ALL'd
+   * with json_each over the new events wrapped in json_group_array — a single
+   * UPDATE expression. SQLite serializes this against concurrent writers on
+   * the same row, so two callers appending simultaneously cannot lose each
+   * other's events (the previous implementation serialized only the supplied
+   * array and overwrote, dropping any pre-existing history).
+   *
+   * Sets the `last_verified_*` convenience columns from the latest event in
+   * the union (computed in code; see {@link latestVerified}).
+   */
+  async writeOkfTrust(entryId, entityId, verified, tx) {
+    const executor = this.getExecutor(tx);
+    if (verified.length === 0) return;
+    const latest = coreOkf.latestVerified(verified, Date.now());
+    const newEventsJson = JSON.stringify(verified);
+    await executor.runAsync(
+      `UPDATE ${this.prefix}entries
+         SET okf_verified = COALESCE(
+           (SELECT json_group_array(json_object('by', s.by_val, 'at', s.at_val))
+            FROM (
+              SELECT json_extract(value, '$.by') AS by_val,
+                     json_extract(value, '$.at') AS at_val
+              FROM json_each(okf_verified)
+              UNION ALL
+              SELECT json_extract(value, '$.by'),
+                     json_extract(value, '$.at')
+              FROM json_each(?)
+            ) AS s
+            ORDER BY s.at_val),
+           '[]'
+         ),
+         last_verified_by = ?,
+         last_verified_at = ?
+       WHERE id = ? AND entity_id = ?`,
+      [newEventsJson, latest?.by ?? null, latest?.at ?? null, entryId, entityId]
+    );
+  }
+  /** Replace the `sources` list (provenance). */
+  async writeOkfSources(entryId, entityId, sources, tx) {
+    const executor = this.getExecutor(tx);
+    const json = coreOkf.formatSourcesJson(sources);
+    await executor.runAsync(
+      `UPDATE ${this.prefix}entries
+         SET okf_sources = ?
+       WHERE id = ? AND entity_id = ?`,
+      [json, entryId, entityId]
+    );
+  }
+  /** Set the OKF v0.2 lifecycle status. */
+  async setLifecycleStatus(entryId, entityId, status, tx) {
+    const executor = this.getExecutor(tx);
+    await executor.runAsync(
+      `UPDATE ${this.prefix}entries
+         SET lifecycle_status = ?
+       WHERE id = ? AND entity_id = ?`,
+      [status, entryId, entityId]
+    );
+  }
+  /** Set the absolute cutoff (epoch ms) for staleness, or NULL to clear. */
+  async setStaleAfter(entryId, entityId, date, tx) {
+    const executor = this.getExecutor(tx);
+    await executor.runAsync(
+      `UPDATE ${this.prefix}entries
+         SET stale_after = ?
+       WHERE id = ? AND entity_id = ?`,
+      [date, entryId, entityId]
+    );
+  }
+  /** Set the producer / verifier actor string. Rare. */
+  async setGeneratedBy(entryId, entityId, actor, tx) {
+    const executor = this.getExecutor(tx);
+    await executor.runAsync(
+      `UPDATE ${this.prefix}entries
+         SET generated_by = ?
+       WHERE id = ? AND entity_id = ?`,
+      [actor, entryId, entityId]
+    );
+  }
+  // The same five methods exist for tasks, with `tasks` instead of `entries`.
+  // Tasks are symmetric per spec §2.5.
+  /** Atomic append, task variant — mirrors {@link writeOkfTrust}. */
+  async writeOkfTrustTask(taskId, entityId, verified, tx) {
+    const executor = this.getExecutor(tx);
+    if (verified.length === 0) return;
+    const latest = coreOkf.latestVerified(verified, Date.now());
+    const newEventsJson = JSON.stringify(verified);
+    await executor.runAsync(
+      `UPDATE ${this.prefix}tasks
+         SET okf_verified = COALESCE(
+           (SELECT json_group_array(json_object('by', s.by_val, 'at', s.at_val))
+            FROM (
+              SELECT json_extract(value, '$.by') AS by_val,
+                     json_extract(value, '$.at') AS at_val
+              FROM json_each(okf_verified)
+              UNION ALL
+              SELECT json_extract(value, '$.by'),
+                     json_extract(value, '$.at')
+              FROM json_each(?)
+            ) AS s
+            ORDER BY s.at_val),
+           '[]'
+         ),
+         last_verified_by = ?,
+         last_verified_at = ?
+       WHERE id = ? AND entity_id = ?`,
+      [newEventsJson, latest?.by ?? null, latest?.at ?? null, taskId, entityId]
+    );
+  }
+  async writeOkfSourcesTask(taskId, entityId, sources, tx) {
+    const executor = this.getExecutor(tx);
+    const json = coreOkf.formatSourcesJson(sources);
+    await executor.runAsync(
+      `UPDATE ${this.prefix}tasks
+         SET okf_sources = ?
+       WHERE id = ? AND entity_id = ?`,
+      [json, taskId, entityId]
+    );
+  }
+  async setLifecycleStatusTask(taskId, entityId, status, tx) {
+    const executor = this.getExecutor(tx);
+    await executor.runAsync(
+      `UPDATE ${this.prefix}tasks
+         SET lifecycle_status = ?
+       WHERE id = ? AND entity_id = ?`,
+      [status, taskId, entityId]
+    );
+  }
+  async setStaleAfterTask(taskId, entityId, date, tx) {
+    const executor = this.getExecutor(tx);
+    await executor.runAsync(
+      `UPDATE ${this.prefix}tasks
+         SET stale_after = ?
+       WHERE id = ? AND entity_id = ?`,
+      [date, taskId, entityId]
+    );
+  }
+  async setGeneratedByTask(taskId, entityId, actor, tx) {
+    const executor = this.getExecutor(tx);
+    await executor.runAsync(
+      `UPDATE ${this.prefix}tasks
+         SET generated_by = ?
+       WHERE id = ? AND entity_id = ?`,
+      [actor, taskId, entityId]
+    );
+  }
+};
 
 // src/WikiMemory.ts
 var TABLE_PREFIX_PATTERN = /^[A-Za-z][A-Za-z0-9_]{0,30}_$/;
@@ -6251,6 +7092,7 @@ var WikiMemory = class {
       this.entryRepo,
       this.options.config ?? {}
     );
+    this.okfTrustWrites = new OkfTrustWritesRepository(this.db, this.prefix);
   }
   /**
    * Explicit escape hatch for test suites: typed access to composed services for mocks/spies.
@@ -6618,6 +7460,42 @@ var WikiMemory = class {
     );
     this.ontologyService.invalidateCache(entityId);
   }
+  /** Append a verification event to a fact. Does NOT touch `updated_at`. */
+  async writeOkfTrust(entryId, entityId, verified) {
+    return this.okfTrustWrites.writeOkfTrust(entryId, entityId, verified);
+  }
+  /** Replace a fact's source list. Does NOT touch `updated_at`. */
+  async writeOkfSources(entryId, entityId, sources) {
+    return this.okfTrustWrites.writeOkfSources(entryId, entityId, sources);
+  }
+  /** Set a fact's OKF v0.2 lifecycle status. Does NOT touch `updated_at`. */
+  async setLifecycleStatus(entryId, entityId, status) {
+    return this.okfTrustWrites.setLifecycleStatus(entryId, entityId, status);
+  }
+  /** Set a fact's stale_after (epoch ms) or clear it. Does NOT touch `updated_at`. */
+  async setStaleAfter(entryId, entityId, date) {
+    return this.okfTrustWrites.setStaleAfter(entryId, entityId, date);
+  }
+  /** Set a fact's generated_by actor string. Does NOT touch `updated_at`. */
+  async setGeneratedBy(entryId, entityId, actor) {
+    return this.okfTrustWrites.setGeneratedBy(entryId, entityId, actor);
+  }
+  /** Task variants of the same five DAO methods. Symmetric per spec §2.5. */
+  async writeOkfTrustTask(taskId, entityId, verified) {
+    return this.okfTrustWrites.writeOkfTrustTask(taskId, entityId, verified);
+  }
+  async writeOkfSourcesTask(taskId, entityId, sources) {
+    return this.okfTrustWrites.writeOkfSourcesTask(taskId, entityId, sources);
+  }
+  async setLifecycleStatusTask(taskId, entityId, status) {
+    return this.okfTrustWrites.setLifecycleStatusTask(taskId, entityId, status);
+  }
+  async setStaleAfterTask(taskId, entityId, date) {
+    return this.okfTrustWrites.setStaleAfterTask(taskId, entityId, date);
+  }
+  async setGeneratedByTask(taskId, entityId, actor) {
+    return this.okfTrustWrites.setGeneratedByTask(taskId, entityId, actor);
+  }
 };
 _testAccessNonTestEnvWarned = new WeakMap();
 
@@ -6921,13 +7799,87 @@ function formatMemoryDump(dump) {
     files
   };
 }
-var LLM_WIKI_PROFILE = "llm-wiki/1";
-function factFrontmatter(f) {
+var DEFAULT_PROFILE = "llm-wiki/2";
+function isoOrFallback(updatedAt) {
+  if (!Number.isFinite(updatedAt)) return (/* @__PURE__ */ new Date(0)).toISOString();
+  const d = new Date(updatedAt);
+  if (!Number.isFinite(d.getTime())) return (/* @__PURE__ */ new Date(0)).toISOString();
+  return d.toISOString();
+}
+function isoDateOrOmit(ms) {
+  if (ms == null || !Number.isFinite(ms)) return void 0;
+  const d = new Date(ms);
+  if (!Number.isFinite(d.getTime())) return void 0;
+  return d.toISOString().slice(0, 10);
+}
+function factFrontmatterV2(f) {
   return {
     type: f.okf_type ?? "fact",
     title: f.title,
     tags: f.tags,
-    timestamp: new Date(f.updated_at).toISOString(),
+    // `timestamp` rides along deliberately even on the v0.2 path — a naive
+    // consumer that only understands the v0.1 key still gets a readable date
+    // without needing flow-mapping support. `generated.at` is the canonical
+    // v0.2 field and always wins on import when both are present (spec §2.4).
+    timestamp: isoOrFallback(f.updated_at),
+    resource: f.source_ref ?? void 0,
+    id: f.id,
+    entity_id: f.entity_id,
+    confidence: f.confidence,
+    source_type: f.source_type,
+    source_hash: f.source_hash,
+    created_at: f.created_at,
+    access_count: f.access_count,
+    last_accessed_at: f.last_accessed_at,
+    deleted_at: f.deleted_at,
+    // OKF v0.2
+    status: f.lifecycle_status ?? "stable",
+    ...isoDateOrOmit(f.stale_after) ? { stale_after: isoDateOrOmit(f.stale_after) } : {},
+    // Omit `generated` entirely when there's no actor on record — never
+    // fabricate a `generated_by` (mirrors the import side's rule in §4.8:
+    // it never invents one either, so export must not manufacture one that
+    // would then round-trip back in as if it had always been asserted).
+    ...f.generated_by ? { generated: { by: f.generated_by, at: isoOrFallback(f.updated_at) } } : {},
+    // Omit `verified`/`sources` when empty — an emitted `[]` is not the same
+    // shape as an absent key (spec §5.3 derives `unverified` from "no
+    // `verified` key", not from "empty `verified` list").
+    ...f.okf_verified && f.okf_verified.length > 0 ? { verified: f.okf_verified } : {},
+    ...f.okf_sources && f.okf_sources.length > 0 ? { sources: f.okf_sources } : {},
+    ...f.okf_usage_window ? { usage_window: f.okf_usage_window } : {}
+  };
+}
+function taskFrontmatterV2(t) {
+  return {
+    type: t.okf_type ?? "task",
+    title: t.description,
+    timestamp: isoOrFallback(t.updated_at),
+    // see factFrontmatterV2 comment — deliberate back-compat duplication
+    id: t.id,
+    entity_id: t.entity_id,
+    status: t.lifecycle_status ?? "stable",
+    // OKF v0.2 lifecycle
+    execution_status: t.status,
+    // execution state under renamed key
+    priority: t.priority,
+    created_at: t.created_at,
+    resolved_at: t.resolved_at,
+    deleted_at: t.deleted_at,
+    // OKF v0.2 — symmetric with facts (spec §2.5): stale_after applies to
+    // tasks too (a hallucinated task needs a freshness signal as much as a
+    // hallucinated fact does).
+    ...isoDateOrOmit(t.stale_after) ? { stale_after: isoDateOrOmit(t.stale_after) } : {},
+    ...t.generated_by ? { generated: { by: t.generated_by, at: isoOrFallback(t.updated_at) } } : {},
+    ...t.okf_verified && t.okf_verified.length > 0 ? { verified: t.okf_verified } : {},
+    ...t.okf_sources && t.okf_sources.length > 0 ? { sources: t.okf_sources } : {},
+    ...t.okf_usage_window ? { usage_window: t.okf_usage_window } : {}
+  };
+}
+function factFrontmatterV1(f) {
+  return {
+    type: f.okf_type ?? "fact",
+    title: f.title,
+    tags: f.tags,
+    timestamp: isoOrFallback(f.updated_at),
     resource: f.source_ref ?? void 0,
     id: f.id,
     entity_id: f.entity_id,
@@ -6940,11 +7892,11 @@ function factFrontmatter(f) {
     deleted_at: f.deleted_at
   };
 }
-function taskFrontmatter(t) {
+function taskFrontmatterV1(t) {
   return {
     type: t.okf_type ?? "task",
     title: t.description,
-    timestamp: new Date(t.updated_at).toISOString(),
+    timestamp: isoOrFallback(t.updated_at),
     id: t.id,
     entity_id: t.entity_id,
     status: t.status,
@@ -6974,7 +7926,11 @@ function buildEventLogEntries(events, factIdToFilename) {
     return { date: formatLogDate(e.created_at), text: coreOkf.appendEventIdComment(text, e.id) };
   });
 }
-function formatOkfBundle(dump) {
+function formatOkfBundle(dump, options) {
+  const profile = options?.profile ?? DEFAULT_PROFILE;
+  const okfVersion = profile === "llm-wiki/2" ? "0.2" : "0.1";
+  const factFm = profile === "llm-wiki/2" ? factFrontmatterV2 : factFrontmatterV1;
+  const taskFm = profile === "llm-wiki/2" ? taskFrontmatterV2 : taskFrontmatterV1;
   const files = [];
   const rootEntries = [];
   for (const [entityId, bundle] of Object.entries(dump.entities)) {
@@ -7011,7 +7967,7 @@ function formatOkfBundle(dump) {
       const factBody = coreOkf.appendRelatedSection(f.body, relatedLinksFor2(factPath, f.id));
       files.push({
         path: factPath,
-        content: coreOkf.buildConceptDocument(factFrontmatter(f), factBody)
+        content: coreOkf.buildConceptDocument(factFm(f), factBody)
       });
     }
     const taskEntries = bundle.tasks.map((t) => ({
@@ -7023,7 +7979,7 @@ function formatOkfBundle(dump) {
       const taskBody = coreOkf.appendRelatedSection("", relatedLinksFor2(taskPath, t.id));
       files.push({
         path: taskPath,
-        content: coreOkf.buildConceptDocument(taskFrontmatter(t), taskBody)
+        content: coreOkf.buildConceptDocument(taskFm(t), taskBody)
       });
     }
     files.push({
@@ -7046,9 +8002,9 @@ function formatOkfBundle(dump) {
   files.push({
     path: "index.md",
     content: coreOkf.buildRootIndexMd(
-      "0.1",
+      okfVersion,
       rootEntries.length > 0 ? [{ heading: "Entities", entries: rootEntries }] : [],
-      { profile: LLM_WIKI_PROFILE }
+      { profile }
     )
   });
   return { files };
@@ -7138,6 +8094,21 @@ function parseFrontmatterTimestamp(value, fallback) {
   }
   return fallback;
 }
+function parseStaleAfterRaw(raw) {
+  if (typeof raw !== "string") return null;
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(raw);
+  if (!m) return null;
+  const year = Number(m[1]);
+  const month = Number(m[2]);
+  const day = Number(m[3]);
+  const ms = Date.UTC(year, month - 1, day);
+  if (!Number.isFinite(ms)) return null;
+  const d = new Date(ms);
+  if (d.getUTCFullYear() !== year || d.getUTCMonth() + 1 !== month || d.getUTCDate() !== day) {
+    return null;
+  }
+  return ms;
+}
 function unescapeLogSummary(summary) {
   return summary.replace(/\\\]/g, "]").replace(/\\\[/g, "[").replace(/\\\\/g, "\\");
 }
@@ -7155,9 +8126,29 @@ function parseLogEntryText(text) {
 function frontmatterToFact(entityId, id, frontmatter, body, now) {
   const created_at = parseFrontmatterTimestamp(frontmatter.created_at, now);
   const updated_at = parseFrontmatterTimestamp(
-    frontmatter.timestamp,
-    parseFrontmatterTimestamp(frontmatter.updated_at, now)
+    frontmatter.generated?.at,
+    parseFrontmatterTimestamp(
+      frontmatter.timestamp,
+      parseFrontmatterTimestamp(frontmatter.updated_at, now)
+    )
   );
+  const verified = coreOkf.parseVerifiedFlexible(frontmatter.verified);
+  const rawSources = frontmatter.sources;
+  const hasSourcesKey = rawSources !== void 0;
+  const sources = Array.isArray(rawSources) ? rawSources : [];
+  const usageWindow = frontmatter.usage_window && typeof frontmatter.usage_window === "object" ? frontmatter.usage_window : null;
+  const lastV = coreOkf.latestVerified(verified, now);
+  const lifecycleRaw = frontmatter.status;
+  const lifecycle_status = lifecycleRaw === "draft" || lifecycleRaw === "stable" || lifecycleRaw === "deprecated" ? lifecycleRaw : "stable";
+  const staleAfterRaw = frontmatter.stale_after;
+  const stale_after = parseStaleAfterRaw(staleAfterRaw);
+  const generated_by = frontmatter.generated?.by ?? null;
+  if (!hasSourcesKey) {
+    const urls = coreOkf.parseCitationsList(body);
+    for (const url of urls) {
+      sources.push({ resource: url });
+    }
+  }
   return {
     id,
     entity_id: entityId,
@@ -7173,26 +8164,62 @@ function frontmatterToFact(entityId, id, frontmatter, body, now) {
     last_accessed_at: frontmatter.last_accessed_at != null ? parseFrontmatterTimestamp(frontmatter.last_accessed_at, now) : null,
     access_count: typeof frontmatter.access_count === "number" ? frontmatter.access_count : 0,
     deleted_at: frontmatter.deleted_at != null ? parseFrontmatterTimestamp(frontmatter.deleted_at, 0) : null,
-    okf_type: frontmatter.type
+    okf_type: frontmatter.type,
+    // OKF v0.2
+    lifecycle_status,
+    stale_after,
+    generated_by,
+    okf_sources: sources,
+    okf_verified: verified,
+    okf_usage_window: usageWindow,
+    last_verified_at: lastV?.at ?? null,
+    last_verified_by: lastV?.by ?? null
   };
 }
-function frontmatterToTask(entityId, id, frontmatter, now) {
+function frontmatterToTask(entityId, id, frontmatter, now, usesV1StatusRule) {
   const created_at = parseFrontmatterTimestamp(frontmatter.created_at, now);
   const updated_at = parseFrontmatterTimestamp(
-    frontmatter.timestamp,
-    parseFrontmatterTimestamp(frontmatter.updated_at, now)
+    frontmatter.generated?.at,
+    parseFrontmatterTimestamp(
+      frontmatter.timestamp,
+      parseFrontmatterTimestamp(frontmatter.updated_at, now)
+    )
   );
+  const verified = coreOkf.parseVerifiedFlexible(frontmatter.verified);
+  const sources = Array.isArray(frontmatter.sources) ? frontmatter.sources : [];
+  const usageWindow = frontmatter.usage_window && typeof frontmatter.usage_window === "object" ? frontmatter.usage_window : null;
+  const lastV = coreOkf.latestVerified(verified, now);
+  const lifecycleRaw = frontmatter.status;
+  const lifecycle_status = lifecycleRaw === "draft" || lifecycleRaw === "stable" || lifecycleRaw === "deprecated" ? lifecycleRaw : "stable";
+  const staleAfterRaw = frontmatter.stale_after;
+  const stale_after = parseStaleAfterRaw(staleAfterRaw);
+  const executionRaw = frontmatter.execution_status;
+  let executionState;
+  if (usesV1StatusRule) {
+    executionState = TASK_STATUSES.has(String(frontmatter.status)) ? frontmatter.status : "pending";
+  } else {
+    executionState = TASK_STATUSES.has(String(executionRaw)) ? executionRaw : TASK_STATUSES.has(String(frontmatter.status)) ? frontmatter.status : "pending";
+  }
   return {
     id,
     entity_id: entityId,
     description: typeof frontmatter.title === "string" ? frontmatter.title : "",
-    status: TASK_STATUSES.has(String(frontmatter.status)) ? frontmatter.status : "pending",
+    status: executionState,
     priority: typeof frontmatter.priority === "number" ? frontmatter.priority : 0,
     created_at,
     updated_at,
     resolved_at: frontmatter.resolved_at != null ? parseFrontmatterTimestamp(frontmatter.resolved_at, now) : null,
     deleted_at: frontmatter.deleted_at != null ? parseFrontmatterTimestamp(frontmatter.deleted_at, 0) : null,
-    okf_type: frontmatter.type
+    okf_type: frontmatter.type,
+    // OKF v0.2
+    lifecycle_status,
+    stale_after,
+    generated_by: frontmatter.generated?.by ?? null,
+    okf_sources: sources,
+    okf_verified: verified,
+    okf_usage_window: usageWindow,
+    last_verified_at: lastV?.at ?? null,
+    last_verified_by: lastV?.by ?? null
   };
 }
 function findLogMdPath(files) {
@@ -7239,10 +8266,17 @@ function parseOkfBundle(entityId, files, options) {
   );
   const rootIndex = allowedFiles.find((f) => f.path === "index.md");
   const profileMeta = rootIndex ? coreOkf.parseRootIndexMd(rootIndex.content) : {};
-  const isProfile1 = profileMeta.profile === "llm-wiki/1";
+  const okfVersion = profileMeta.okf_version;
+  const profile = profileMeta.profile;
+  const isProfile1 = profile === "llm-wiki/1";
+  const isProfile2 = profile === "llm-wiki/2";
+  const isLegacyV1 = profile === void 0 && okfVersion === "0.1";
+  const isVersionOnlyV2 = profile === void 0 && okfVersion === "0.2";
+  const isUnknownProfileV2 = profile !== void 0 && profile !== "llm-wiki/1" && profile !== "llm-wiki/2" && okfVersion === "0.2";
+  const summaryEligible = isProfile1 || isProfile2 || isLegacyV1 || isVersionOnlyV2 || isUnknownProfileV2;
   let entitySummary;
   const entityIndex = allowedFiles.find((f) => f.path === `${entityPrefix}index.md`);
-  if (isProfile1 && entityIndex) {
+  if (summaryEligible && entityIndex) {
     const summary = coreOkf.parseEntityIndexMd(entityIndex.content).summary;
     entitySummary = summary || void 0;
   }
@@ -7271,11 +8305,12 @@ function parseOkfBundle(entityId, files, options) {
     if (route === "ignore") continue;
     const resolvedId = typeof frontmatter.id === "string" && frontmatter.id ? frontmatter.id : basenameMd(file.path);
     const { body: storedBody, relatedLinks } = coreOkf.splitRelatedSection(body);
-    const edgeLinks = isProfile1 ? relatedLinks : [...relatedLinks, ...coreOkf.extractMarkdownLinks(storedBody)];
+    const edgeLinks = isProfile1 || isLegacyV1 ? relatedLinks : [...relatedLinks, ...coreOkf.extractMarkdownLinks(storedBody)];
+    const usesV1StatusRule = isProfile1 || isLegacyV1 || profile === void 0 && okfVersion === void 0;
     if (route === "fact") {
       facts.push(frontmatterToFact(entityId, resolvedId, frontmatter, storedBody, now));
     } else {
-      tasks.push(frontmatterToTask(entityId, resolvedId, frontmatter, now));
+      tasks.push(frontmatterToTask(entityId, resolvedId, frontmatter, now, usesV1StatusRule));
     }
     const seenEdges = /* @__PURE__ */ new Set();
     extractEdgesFromLinks(
@@ -7384,7 +8419,9 @@ exports.PromptService = PromptService;
 exports.PrunePartialFailureError = PrunePartialFailureError;
 exports.WikiBusyError = WikiBusyError;
 exports.WikiDuplicateHashError = WikiDuplicateHashError;
+exports.WikiIngestEmptyError = WikiIngestEmptyError;
 exports.WikiMemory = WikiMemory;
+exports.WikiParseError = WikiParseError;
 exports.WikiSourceRefHashCollision = WikiSourceRefHashCollision;
 exports.WikiStrictOntologyViolation = WikiStrictOntologyViolation;
 exports.WikiTransactionError = WikiTransactionError;