@runweave/server-linux-arm64 0.0.0-stage → 0.1.2

package/payload/backend/evolution-sqlite-worker.cjs

@@ -0,0 +1,2073 @@
+const __IMPORT_META_URL__ = require('url').pathToFileURL(__filename).href;
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// backend/src/evolution/storage/sqlite-worker.ts
+var import_node_worker_threads = require("node:worker_threads");
+
+// backend/src/evolution/storage/artifact-reads.ts
+var PAGE_BYTES = 512 * 1024;
+var EvolutionArtifactReads = class {
+  constructor(database2) {
+    this.database = database2;
+  }
+  summaries = /* @__PURE__ */ new Map();
+  overview(runId) {
+    const cacheAllowed = !this.database.inTransaction;
+    return this.database.transaction(() => ({
+      contextPack: this.summary(runId, cacheAllowed),
+      segmentCount: this.count("trace_segments", runId),
+      episodeCount: this.count("episodes", runId)
+    }))();
+  }
+  count(table, runId, boundary) {
+    return this.database.prepare(
+      `SELECT COUNT(*) AS n FROM ${table} WHERE run_id = ?
+      ${boundary === void 0 ? "" : "AND rowid <= ?"}`
+    ).get(...boundary === void 0 ? [runId] : [runId, boundary]).n;
+  }
+  summary(runId, cacheAllowed) {
+    const identity = this.database.prepare(
+      "SELECT context_pack_id, digest FROM context_packs WHERE run_id = ?"
+    ).get(runId);
+    if (!identity) return null;
+    const cached = this.summaries.get(identity.context_pack_id);
+    if (cacheAllowed && cached?.digest === identity.digest) return cached.value;
+    const row = this.database.prepare(
+      `SELECT
+      json_remove(manifest_json, '$.evidence', '$.dataQualityIssues') AS metadata,
+      json_array_length(manifest_json, '$.evidence') AS evidenceCount,
+      json_array_length(manifest_json, '$.dataQualityIssues') AS dataQualityIssueCount
+      FROM context_packs WHERE run_id = ?`
+    ).get(runId);
+    const workspaceCount = this.database.prepare(
+      `SELECT COUNT(DISTINCT json_extract(item.value, '$.origin.projectId')) AS n
+      FROM context_packs pack, json_each(pack.manifest_json, '$.evidence') item
+      WHERE pack.run_id = ? AND json_extract(item.value, '$.source') = 'activity'
+        AND json_extract(item.value, '$.origin.projectId') != ''`
+    ).get(runId).n;
+    const dataQualitySummary = this.database.prepare(
+      `SELECT json_extract(item.value, '$.code') AS code,
+      COUNT(*) AS count, json_extract(item.value, '$.detail') AS detail, MIN(CAST(item.key AS INTEGER)) AS firstIndex
+      FROM context_packs pack, json_each(pack.manifest_json, '$.dataQualityIssues') item
+      WHERE pack.run_id = ? GROUP BY code`
+    ).all(runId);
+    dataQualitySummary.sort(
+      (a, b) => b.count - a.count || a.code.localeCompare(b.code)
+    );
+    const value = {
+      ...JSON.parse(row.metadata),
+      evidenceCount: row.evidenceCount,
+      dataQualityIssueCount: row.dataQualityIssueCount,
+      workspaceCount,
+      dataQualitySummary: dataQualitySummary.map(({ code, count, detail }) => ({
+        code,
+        count,
+        detail
+      }))
+    };
+    if (cacheAllowed) {
+      if (this.summaries.size >= 32)
+        this.summaries.delete(this.summaries.keys().next().value);
+      this.summaries.set(identity.context_pack_id, {
+        digest: identity.digest,
+        value
+      });
+    }
+    return value;
+  }
+  page(runId, query) {
+    const { collection } = query;
+    if (!["evidence", "data-quality", "segments", "episodes"].includes(collection))
+      throw new Error("evolution_artifact_query_invalid");
+    const limit = query.limit ?? 25;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)
+      throw new Error("evolution_artifact_query_invalid");
+    const cursor = query.cursor ? decodeCursor(query.cursor, runId, collection) : void 0;
+    return this.database.transaction(() => {
+      const offset = cursor?.offset ?? 0;
+      let boundary;
+      let total;
+      let rows;
+      if (collection === "evidence" || collection === "data-quality") {
+        const pack = this.database.prepare(
+          "SELECT context_pack_id, digest FROM context_packs WHERE run_id = ?"
+        ).get(runId);
+        boundary = pack ? `${pack.context_pack_id}:${pack.digest}` : "missing";
+        if (cursor && cursor.boundary !== boundary)
+          throw new Error("evolution_artifact_cursor_stale");
+        const field = collection === "evidence" ? "evidence" : "dataQualityIssues";
+        total = pack ? this.database.prepare(
+          `SELECT json_array_length(manifest_json, '$.${field}') AS n
+          FROM context_packs WHERE run_id = ?`
+        ).get(runId).n : 0;
+        rows = this.database.prepare(
+          `SELECT item.value AS payload FROM context_packs pack,
+          json_each(pack.manifest_json, '$.${field}') item WHERE pack.run_id = ? AND CAST(item.key AS INTEGER) >= ?
+          ORDER BY CAST(item.key AS INTEGER) LIMIT ?`
+        ).iterate(runId, offset, limit);
+      } else {
+        const table = collection === "segments" ? "trace_segments" : "episodes";
+        const order = collection === "segments" ? "sequence, segment_id" : "created_at, episode_id";
+        boundary = cursor?.boundary ?? this.database.prepare(
+          `SELECT COALESCE(MAX(rowid), 0) AS n
+          FROM ${table} WHERE run_id = ?`
+        ).get(runId).n;
+        if (typeof boundary !== "number")
+          throw new Error("evolution_artifact_query_invalid");
+        total = this.count(table, runId, boundary);
+        rows = this.database.prepare(
+          `SELECT payload_json AS payload FROM ${table}
+          WHERE run_id = ? AND rowid <= ? ORDER BY ${order} LIMIT ? OFFSET ?`
+        ).iterate(runId, boundary, limit, offset);
+      }
+      const items = [];
+      let bytes = 0;
+      for (const row of rows) {
+        const size = Buffer.byteLength(row.payload);
+        if (items.length > 0 && bytes + size > PAGE_BYTES) break;
+        items.push(JSON.parse(row.payload));
+        bytes += size;
+      }
+      const nextOffset = offset + items.length;
+      return {
+        collection,
+        items,
+        total,
+        nextCursor: nextOffset < total ? Buffer.from(
+          JSON.stringify({
+            runId,
+            collection,
+            offset: nextOffset,
+            boundary
+          })
+        ).toString("base64url") : null
+      };
+    })();
+  }
+};
+function decodeCursor(value, runId, collection) {
+  try {
+    const cursor = JSON.parse(
+      Buffer.from(value, "base64url").toString("utf8")
+    );
+    if (cursor.runId === runId && cursor.collection === collection && Number.isSafeInteger(cursor.offset) && cursor.offset >= 0 && (typeof cursor.boundary === "string" && cursor.boundary.length <= 512 || Number.isSafeInteger(cursor.boundary) && Number(cursor.boundary) >= 0))
+      return cursor;
+  } catch {
+  }
+  throw new Error("evolution_artifact_query_invalid");
+}
+
+// backend/src/evolution/storage/repository-database.ts
+function initializeEvolutionRepositories(database2) {
+  database2.exec(`
+    CREATE TABLE IF NOT EXISTS evolution_repositories(repository_id TEXT PRIMARY KEY, payload_json TEXT NOT NULL);
+    CREATE TABLE IF NOT EXISTS evolution_repository_bindings(
+      kind TEXT NOT NULL, id TEXT NOT NULL, payload_json TEXT NOT NULL, PRIMARY KEY(kind,id));
+    CREATE TABLE IF NOT EXISTS evolution_topic_lineage(
+      canonical_insight_id TEXT NOT NULL, legacy_insight_id TEXT PRIMARY KEY, status TEXT NOT NULL);
+    CREATE TABLE IF NOT EXISTS evolution_reflection_batches(
+      batch_id TEXT PRIMARY KEY, idempotency_key TEXT NOT NULL UNIQUE, payload_json TEXT NOT NULL);
+    CREATE TABLE IF NOT EXISTS evolution_repository_migrations(
+      migration_id TEXT PRIMARY KEY, payload_json TEXT NOT NULL);
+  `);
+  const columns = database2.prepare("PRAGMA table_info(evolution_runs)").all();
+  if (!columns.some((column) => column.name === "repository_json"))
+    database2.exec("ALTER TABLE evolution_runs ADD COLUMN repository_json TEXT");
+}
+function readRepositoryAttribution(database2, kind, id) {
+  const row = database2.prepare(
+    "SELECT payload_json FROM evolution_repository_bindings WHERE kind = ? AND id = ?"
+  ).get(kind, id);
+  return row ? JSON.parse(row.payload_json) : void 0;
+}
+function executeRepositoryCommand(database2, foundation, command) {
+  switch (command.op) {
+    case "list":
+      return database2.prepare(
+        "SELECT payload_json FROM evolution_repositories ORDER BY repository_id"
+      ).all().map((row) => JSON.parse(row.payload_json));
+    case "put": {
+      return database2.transaction(() => {
+        const row = database2.prepare(
+          "SELECT payload_json FROM evolution_repositories WHERE repository_id = ?"
+        ).get(command.repository.repositoryId);
+        const previous = row ? JSON.parse(row.payload_json) : null;
+        if (previous && previous.commonDirectory !== command.repository.commonDirectory)
+          throw new Error("evolution_repository_identity_conflict");
+        const repository = {
+          ...command.repository,
+          paths: [
+            .../* @__PURE__ */ new Set([
+              ...previous?.paths ?? [],
+              ...command.repository.paths
+            ])
+          ],
+          projectIds: [
+            .../* @__PURE__ */ new Set([
+              ...previous?.projectIds ?? [],
+              ...command.repository.projectIds
+            ])
+          ]
+        };
+        database2.prepare(
+          "INSERT INTO evolution_repositories VALUES (?,?) ON CONFLICT(repository_id) DO UPDATE SET payload_json=excluded.payload_json"
+        ).run(repository.repositoryId, JSON.stringify(repository));
+        return true;
+      }).immediate();
+    }
+    case "attribution":
+      return readRepositoryAttribution(database2, command.kind, command.id) ?? null;
+    case "batch-get": {
+      const row = database2.prepare(
+        "SELECT payload_json FROM evolution_reflection_batches WHERE idempotency_key = ?"
+      ).get(command.key);
+      return row ? JSON.parse(row.payload_json) : null;
+    }
+    case "batch-create":
+      return database2.transaction(() => {
+        const previous = executeRepositoryCommand(database2, foundation, {
+          op: "batch-get",
+          key: command.batch.idempotencyKey
+        });
+        if (previous) return previous;
+        for (const run of command.runs) foundation.createRun(run);
+        database2.prepare("INSERT INTO evolution_reflection_batches VALUES (?,?,?)").run(
+          command.batch.batchId,
+          command.batch.idempotencyKey,
+          JSON.stringify(command.batch)
+        );
+        return command.batch;
+      }).immediate();
+  }
+}
+
+// backend/src/evolution/storage/database.ts
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+
+// backend/src/evolution/storage/database-helpers.ts
+function insertImmutable(database2, params) {
+  const existing = database2.prepare(
+    `SELECT payload_json FROM ${params.table} WHERE ${params.idColumn} = ?`
+  ).get(params.id);
+  if (existing) {
+    if (existing.payload_json !== params.payload) {
+      throw new Error("evolution_immutable_artifact_conflict");
+    }
+    return;
+  }
+  params.insert();
+}
+
+// backend/src/evolution/storage/artifact-database.ts
+var EvolutionArtifactDatabase = class {
+  constructor(database2) {
+    this.database = database2;
+  }
+  putRuntimeTrace(trace) {
+    this.database.transaction(() => {
+      this.database.prepare(
+        `INSERT OR IGNORE INTO runtime_traces
+            (trace_id, run_id, created_at, payload_json)
+           VALUES (?, ?, ?, ?)`
+      ).run(
+        trace.traceId,
+        trace.runId,
+        trace.createdAt,
+        JSON.stringify({ ...trace, events: [] })
+      );
+      for (const event of trace.events) {
+        this.appendRuntimeTraceEvent(event);
+      }
+    })();
+  }
+  appendRuntimeTraceEvent(event) {
+    this.database.prepare(
+      `INSERT OR IGNORE INTO runtime_trace_events
+          (event_id, trace_id, at, payload_json)
+         VALUES (?, ?, ?, ?)`
+    ).run(event.eventId, event.traceId, event.at, JSON.stringify(event));
+  }
+  getRuntimeTrace(traceId) {
+    const row = this.database.prepare("SELECT payload_json FROM runtime_traces WHERE trace_id = ?").get(traceId);
+    if (!row) return null;
+    const trace = JSON.parse(row.payload_json);
+    return {
+      ...trace,
+      attribution: readRepositoryAttribution(this.database, "trace", traceId),
+      events: this.listEvents(traceId)
+    };
+  }
+  listRuntimeTraces(runId) {
+    const rows = this.database.prepare(
+      "SELECT trace_id FROM runtime_traces WHERE run_id = ? ORDER BY created_at"
+    ).all(runId);
+    return rows.flatMap((row) => {
+      const trace = this.getRuntimeTrace(row.trace_id);
+      return trace ? [trace] : [];
+    });
+  }
+  listRecentRuntimeTraces(learningScopeId, limit) {
+    const rows = learningScopeId ? this.database.prepare(
+      `SELECT trace_id FROM runtime_traces
+             WHERE json_extract(payload_json, '$.learningScopeId') = ? OR EXISTS (
+               SELECT 1 FROM evolution_repository_bindings binding, json_each(binding.payload_json, '$.repositoryIds') repo
+               WHERE binding.kind='trace' AND binding.id=runtime_traces.trace_id AND repo.value=?
+             )
+             ORDER BY created_at DESC, trace_id
+             LIMIT ?`
+    ).all(learningScopeId, learningScopeId, limit) : this.database.prepare(
+      `SELECT trace_id FROM runtime_traces
+             ORDER BY created_at DESC, trace_id
+             LIMIT ?`
+    ).all(limit);
+    return rows.flatMap((row) => {
+      const trace = this.getRuntimeTrace(row.trace_id);
+      return trace ? [trace] : [];
+    });
+  }
+  listEvents(traceId) {
+    const rows = this.database.prepare(
+      `SELECT payload_json FROM runtime_trace_events
+         WHERE trace_id = ? ORDER BY at, rowid`
+    ).all(traceId);
+    return rows.map((row) => JSON.parse(row.payload_json));
+  }
+  putContextPack(manifest) {
+    const manifestJson = JSON.stringify(manifest);
+    this.database.transaction(() => {
+      const existing = this.database.prepare(
+        `SELECT manifest_json FROM context_packs
+             WHERE context_pack_id = ? OR run_id = ?
+             LIMIT 1`
+      ).get(manifest.contextPackId, manifest.runId);
+      if (existing) {
+        if (existing.manifest_json !== manifestJson) {
+          throw new Error("evolution_context_pack_identity_conflict");
+        }
+        return;
+      }
+      this.database.prepare(
+        `INSERT INTO context_packs (
+              context_pack_id, run_id, learning_scope_id, digest,
+              created_at_ms, manifest_json
+            ) VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(
+        manifest.contextPackId,
+        manifest.runId,
+        manifest.learningScope.learningScopeId,
+        manifest.digest,
+        Date.parse(manifest.createdAt),
+        manifestJson
+      );
+      const insertSource = this.database.prepare(
+        `INSERT INTO context_pack_sources (
+            context_pack_id, source_id, source, boundary_json
+          ) VALUES (?, ?, ?, ?)`
+      );
+      for (const source of manifest.sources) {
+        insertSource.run(
+          manifest.contextPackId,
+          source.sourceId,
+          source.source,
+          JSON.stringify(source)
+        );
+      }
+    }).immediate();
+  }
+  getContextPack(contextPackId) {
+    return this.readContextPack("context_pack_id", contextPackId);
+  }
+  getContextPackByRun(runId) {
+    return this.readContextPack("run_id", runId);
+  }
+  readContextPack(column, value) {
+    const row = this.database.prepare(`SELECT manifest_json FROM context_packs WHERE ${column} = ?`).get(value);
+    return row ? JSON.parse(row.manifest_json) : null;
+  }
+  putTraceSegments(segments) {
+    const insert = this.database.prepare(
+      `INSERT INTO trace_segments (
+        segment_id, run_id, learning_scope_id, sequence, payload_json
+      ) VALUES (?, ?, ?, ?, ?)`
+    );
+    this.database.transaction(() => {
+      for (const segment of segments) {
+        insertImmutable(this.database, {
+          table: "trace_segments",
+          idColumn: "segment_id",
+          id: segment.segmentId,
+          payload: JSON.stringify(segment),
+          insert: () => insert.run(
+            segment.segmentId,
+            segment.runId,
+            segment.learningScopeId,
+            segment.sequence,
+            JSON.stringify(segment)
+          )
+        });
+      }
+    }).immediate();
+  }
+  listTraceSegments(runId) {
+    return this.readPayloadRows(
+      `SELECT payload_json FROM trace_segments
+       WHERE run_id = ? ORDER BY sequence, segment_id`,
+      runId
+    );
+  }
+  putEpisodes(episodes) {
+    const insert = this.database.prepare(
+      `INSERT INTO episodes (
+        episode_id, run_id, learning_scope_id, created_at, payload_json
+      ) VALUES (?, ?, ?, ?, ?)`
+    );
+    this.database.transaction(() => {
+      for (const episode of episodes) {
+        insertImmutable(this.database, {
+          table: "episodes",
+          idColumn: "episode_id",
+          id: episode.episodeId,
+          payload: JSON.stringify(episode),
+          insert: () => insert.run(
+            episode.episodeId,
+            episode.runId,
+            episode.learningScopeId,
+            episode.createdAt,
+            JSON.stringify(episode)
+          )
+        });
+      }
+    }).immediate();
+  }
+  listEpisodes(runId) {
+    return this.readPayloadRows(
+      `SELECT payload_json FROM episodes
+       WHERE run_id = ? ORDER BY created_at, episode_id`,
+      runId
+    );
+  }
+  putAnalysisReport(report) {
+    const payload = JSON.stringify(report);
+    insertImmutable(this.database, {
+      table: "analysis_reports",
+      idColumn: "report_id",
+      id: report.reportId,
+      payload,
+      insert: () => this.database.prepare(
+        `INSERT INTO analysis_reports (
+              report_id, run_id, attempt_number, role, created_at, payload_json
+            ) VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(
+        report.reportId,
+        report.runId,
+        report.attemptNumber,
+        report.role,
+        report.createdAt,
+        payload
+      )
+    });
+  }
+  listAnalysisReports(runId) {
+    return this.readPayloadRows(
+      `SELECT payload_json FROM analysis_reports
+       WHERE run_id = ? ORDER BY attempt_number, created_at, report_id`,
+      runId
+    );
+  }
+  putRunAttempt(attempt) {
+    const existing = this.database.prepare(
+      "SELECT payload_json FROM evolution_run_attempts WHERE attempt_id = ?"
+    ).get(attempt.attemptId);
+    if (!existing) {
+      this.database.prepare(
+        `INSERT INTO evolution_run_attempts (
+            attempt_id, run_id, attempt_number, role, provider, status,
+            started_at, completed_at, payload_json
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        attempt.attemptId,
+        attempt.runId,
+        attempt.attemptNumber,
+        attempt.role,
+        attempt.provider,
+        attempt.status,
+        attempt.startedAt,
+        attempt.completedAt,
+        JSON.stringify(attempt)
+      );
+      return;
+    }
+    const current = JSON.parse(existing.payload_json);
+    if (current.runId !== attempt.runId || current.attemptNumber !== attempt.attemptNumber || current.role !== attempt.role || current.provider !== attempt.provider || current.selectionReason !== attempt.selectionReason || current.startedAt !== attempt.startedAt) {
+      throw new Error("evolution_run_attempt_identity_conflict");
+    }
+    if (current.status !== "running" && current.status !== attempt.status) {
+      throw new Error("evolution_run_attempt_terminal");
+    }
+    this.database.prepare(
+      `UPDATE evolution_run_attempts
+         SET status = ?, completed_at = ?, payload_json = ?
+         WHERE attempt_id = ?`
+    ).run(
+      attempt.status,
+      attempt.completedAt,
+      JSON.stringify(attempt),
+      attempt.attemptId
+    );
+  }
+  listRunAttempts(runId) {
+    return this.readPayloadRows(
+      `SELECT payload_json FROM evolution_run_attempts
+       WHERE run_id = ? ORDER BY attempt_number, started_at, attempt_id`,
+      runId
+    );
+  }
+  putClaims(claims) {
+    const insert = this.database.prepare(
+      `INSERT INTO claims (
+        claim_id, run_id, learning_scope_id, topic_key, created_at, payload_json
+      ) VALUES (?, ?, ?, ?, ?, ?)`
+    );
+    this.database.transaction(() => {
+      for (const claim of claims) {
+        insertImmutable(this.database, {
+          table: "claims",
+          idColumn: "claim_id",
+          id: claim.claimId,
+          payload: JSON.stringify(claim),
+          insert: () => insert.run(
+            claim.claimId,
+            claim.runId,
+            claim.learningScopeId,
+            claim.topicKey,
+            claim.createdAt,
+            JSON.stringify(claim)
+          )
+        });
+      }
+    }).immediate();
+  }
+  listClaims(runId) {
+    return this.readPayloadRows(
+      `SELECT payload_json FROM claims
+       WHERE run_id = ? ORDER BY topic_key, claim_id`,
+      runId
+    );
+  }
+  putClaimNovelty(items) {
+    const insert = this.database.prepare(
+      `INSERT INTO claim_novelty (
+        claim_id, run_id, novelty, payload_json
+      ) VALUES (?, ?, ?, ?)`
+    );
+    this.database.transaction(() => {
+      for (const item of items) {
+        const claim = this.database.prepare("SELECT run_id FROM claims WHERE claim_id = ?").get(item.claimId);
+        if (!claim) throw new Error("evolution_claim_not_found");
+        insertImmutable(this.database, {
+          table: "claim_novelty",
+          idColumn: "claim_id",
+          id: item.claimId,
+          payload: JSON.stringify(item),
+          insert: () => insert.run(
+            item.claimId,
+            claim.run_id,
+            item.novelty,
+            JSON.stringify(item)
+          )
+        });
+      }
+    }).immediate();
+  }
+  listClaimNovelty(runId) {
+    return this.readPayloadRows(
+      `SELECT payload_json FROM claim_novelty
+       WHERE run_id = ? ORDER BY claim_id`,
+      runId
+    );
+  }
+  readPayloadRows(sql, value) {
+    const rows = this.database.prepare(sql).all(value);
+    return rows.map((row) => JSON.parse(row.payload_json));
+  }
+};
+
+// backend/src/evolution/storage/foundation-rules.ts
+var EVOLUTION_ACTIVE_STAGES = [
+  "snapshotting",
+  "segmenting",
+  "independent_analysis",
+  "cross_questioning",
+  "adjudicating",
+  "novelty_check",
+  "validating"
+];
+var EVOLUTION_TERMINAL_STAGES = [
+  "completed",
+  "no_material_novelty",
+  "partial",
+  "failed",
+  "cancelled",
+  "blocked"
+];
+function evolutionTriggerPriority(type) {
+  if (type === "manual") return 0;
+  if (type === "event") return 1;
+  return 2;
+}
+function parseEvolutionTimestamp(value) {
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed)) throw new Error("evolution_invalid_timestamp");
+  return parsed;
+}
+function isAllowedEvolutionRunTransition(current, next) {
+  if (next === "partial" || next === "failed" || next === "blocked") {
+    return EVOLUTION_ACTIVE_STAGES.includes(current);
+  }
+  if (current === "snapshotting") return next === "segmenting";
+  if (current === "segmenting") return next === "independent_analysis";
+  if (current === "independent_analysis") {
+    return next === "cross_questioning";
+  }
+  if (current === "cross_questioning") {
+    return next === "adjudicating" || next === "novelty_check";
+  }
+  if (current === "adjudicating") return next === "novelty_check";
+  if (current === "novelty_check") return next === "validating";
+  if (current === "validating") {
+    return next === "completed" || next === "no_material_novelty";
+  }
+  return false;
+}
+function assertScheduleMaterialization(current, params) {
+  const trigger = params.run.trigger;
+  if (trigger.type !== "schedule" || trigger.scheduleId !== current.scheduleId || parseEvolutionTimestamp(trigger.dueAt) < parseEvolutionTimestamp(params.expectedNextDueAt) || parseEvolutionTimestamp(trigger.dueAt) > parseEvolutionTimestamp(params.now) || params.run.learningScopeId !== current.learningScopeId || params.nextSchedule.scheduleId !== current.scheduleId || params.nextSchedule.learningScopeId !== current.learningScopeId || params.nextSchedule.lastDueAt !== trigger.dueAt || params.nextSchedule.lastRunId !== params.run.runId) {
+    throw new Error("evolution_schedule_materialization_invalid");
+  }
+}
+
+// backend/src/evolution/storage/foundation-database-rows.ts
+function toRun(row) {
+  return {
+    runId: row.run_id,
+    ...row.repository_json ? {
+      repository: JSON.parse(
+        row.repository_json
+      )
+    } : {},
+    learningScopeId: row.learning_scope_id,
+    trigger: JSON.parse(row.trigger_json),
+    profile: row.profile,
+    providerPolicy: row.provider_policy,
+    budget: JSON.parse(row.budget_json),
+    dataRange: JSON.parse(row.data_range_json),
+    stage: row.stage,
+    outcome: row.outcome,
+    createdAt: toIso(row.created_at_ms),
+    updatedAt: toIso(row.updated_at_ms),
+    startedAt: row.started_at_ms === null ? null : toIso(row.started_at_ms),
+    completedAt: row.completed_at_ms === null ? null : toIso(row.completed_at_ms),
+    attempt: row.attempt
+  };
+}
+function nullableTimestamp(value) {
+  return value === null ? null : parseEvolutionTimestamp(value);
+}
+function toIso(value) {
+  return new Date(value).toISOString();
+}
+function placeholders(count) {
+  return Array.from({ length: count }, () => "?").join(", ");
+}
+
+// backend/src/evolution/storage/foundation-database.ts
+var GLOBAL_LEASE_KEY = "global-evolution-runner-v1";
+var EvolutionFoundationDatabase = class {
+  constructor(database2) {
+    this.database = database2;
+  }
+  createRun(run) {
+    this.database.prepare(
+      `INSERT INTO evolution_runs (
+          run_id, learning_scope_id, trigger_type, priority, trigger_json,
+          profile, provider_policy, budget_json, data_range_json, stage,
+          outcome, created_at_ms, updated_at_ms, started_at_ms,
+          completed_at_ms, attempt, owner_id, fencing_token, repository_json
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, ?)`
+    ).run(
+      run.runId,
+      run.learningScopeId,
+      run.trigger.type,
+      evolutionTriggerPriority(run.trigger.type),
+      JSON.stringify(run.trigger),
+      run.profile,
+      run.providerPolicy,
+      JSON.stringify(run.budget),
+      JSON.stringify(run.dataRange),
+      run.stage,
+      run.outcome,
+      parseEvolutionTimestamp(run.createdAt),
+      parseEvolutionTimestamp(run.updatedAt),
+      nullableTimestamp(run.startedAt),
+      nullableTimestamp(run.completedAt),
+      run.attempt,
+      run.repository ? JSON.stringify(run.repository) : null
+    );
+  }
+  getRun(runId) {
+    const row = this.database.prepare("SELECT * FROM evolution_runs WHERE run_id = ?").get(runId);
+    return row ? this.presentRun(row) : null;
+  }
+  listRuns(query = {}) {
+    const conditions = [];
+    const params = [];
+    if (query.learningScopeId) {
+      conditions.push(
+        `(learning_scope_id = ? OR EXISTS (SELECT 1 FROM evolution_repository_bindings binding, json_each(binding.payload_json, '$.repositoryIds') item WHERE binding.kind = 'run' AND binding.id = evolution_runs.run_id AND item.value = ?))`
+      );
+      params.push(query.learningScopeId, query.learningScopeId);
+    }
+    if (query.stage) {
+      conditions.push("stage = ?");
+      params.push(query.stage);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = Math.min(Math.max(query.limit ?? 100, 1), 200);
+    const rows = this.database.prepare(
+      `SELECT * FROM evolution_runs ${where}
+         ORDER BY created_at_ms DESC, run_id DESC LIMIT ?`
+    ).all(...params, limit);
+    return rows.map((row) => this.presentRun(row));
+  }
+  presentRun(row) {
+    const attribution = readRepositoryAttribution(
+      this.database,
+      "run",
+      row.run_id
+    );
+    return { ...toRun(row), ...attribution ? { attribution } : {} };
+  }
+  claimNextRun(params) {
+    const nowMs = parseEvolutionTimestamp(params.now);
+    return this.database.transaction(() => {
+      this.recoverExpiredRunsAt(nowMs);
+      const active = this.database.prepare(
+        `SELECT 1 FROM evolution_runs
+             WHERE stage IN (${placeholders(EVOLUTION_ACTIVE_STAGES.length)})
+             LIMIT 1`
+      ).get(...EVOLUTION_ACTIVE_STAGES);
+      if (active) return null;
+      const lease = this.getLease();
+      if (lease && lease.expires_at_ms > nowMs) return null;
+      const row = this.database.prepare(
+        `SELECT * FROM evolution_runs
+             WHERE stage = 'queued'
+             ORDER BY priority, created_at_ms, run_id
+             LIMIT 1`
+      ).get();
+      if (!row) return null;
+      const fencingToken = (lease?.fencing_token ?? 0) + 1;
+      const expiresAtMs = nowMs + params.leaseTtlMs;
+      this.database.prepare(
+        `INSERT INTO evolution_leases (
+              lease_key, owner_id, fencing_token, acquired_at_ms, expires_at_ms
+            ) VALUES (?, ?, ?, ?, ?)
+            ON CONFLICT(lease_key) DO UPDATE SET
+              owner_id = excluded.owner_id,
+              fencing_token = excluded.fencing_token,
+              acquired_at_ms = excluded.acquired_at_ms,
+              expires_at_ms = excluded.expires_at_ms`
+      ).run(
+        GLOBAL_LEASE_KEY,
+        params.ownerId,
+        fencingToken,
+        nowMs,
+        expiresAtMs
+      );
+      const result = this.database.prepare(
+        `UPDATE evolution_runs
+             SET stage = 'snapshotting', updated_at_ms = ?,
+                 started_at_ms = COALESCE(started_at_ms, ?),
+                 attempt = attempt + 1, owner_id = ?, fencing_token = ?
+             WHERE run_id = ? AND stage = 'queued'`
+      ).run(nowMs, nowMs, params.ownerId, fencingToken, row.run_id);
+      if (result.changes !== 1)
+        throw new Error("evolution_run_claim_conflict");
+      return {
+        run: this.requireRun(row.run_id),
+        ownerId: params.ownerId,
+        fencingToken,
+        leaseExpiresAt: toIso(expiresAtMs)
+      };
+    }).immediate();
+  }
+  heartbeatRunClaim(params) {
+    const nowMs = parseEvolutionTimestamp(params.now);
+    const expiresAtMs = nowMs + params.leaseTtlMs;
+    const result = this.database.prepare(
+      `UPDATE evolution_leases SET expires_at_ms = ?
+         WHERE lease_key = ? AND owner_id = ? AND fencing_token = ?
+           AND expires_at_ms > ?`
+    ).run(
+      expiresAtMs,
+      GLOBAL_LEASE_KEY,
+      params.ownerId,
+      params.fencingToken,
+      nowMs
+    );
+    if (result.changes !== 1) throw new Error("evolution_lease_lost");
+    return toIso(expiresAtMs);
+  }
+  transitionRun(transition) {
+    if (!isAllowedEvolutionRunTransition(
+      transition.expectedStage,
+      transition.nextStage
+    )) {
+      throw new Error("evolution_run_transition_invalid");
+    }
+    const nowMs = parseEvolutionTimestamp(transition.now);
+    return this.database.transaction(() => {
+      this.assertLease(transition.ownerId, transition.fencingToken, nowMs);
+      const current = this.requireRunRow(transition.runId);
+      if (current.stage !== transition.expectedStage || current.owner_id !== transition.ownerId || current.fencing_token !== transition.fencingToken) {
+        throw new Error("evolution_run_transition_conflict");
+      }
+      const terminal = EVOLUTION_TERMINAL_STAGES.includes(
+        transition.nextStage
+      );
+      const outcome = terminal ? transition.outcome ?? transition.nextStage : null;
+      this.database.prepare(
+        `UPDATE evolution_runs
+             SET stage = ?, outcome = ?, updated_at_ms = ?,
+                 completed_at_ms = ?, owner_id = ?, fencing_token = ?
+             WHERE run_id = ?`
+      ).run(
+        transition.nextStage,
+        outcome,
+        nowMs,
+        terminal ? nowMs : null,
+        terminal ? null : transition.ownerId,
+        terminal ? null : transition.fencingToken,
+        transition.runId
+      );
+      if (terminal)
+        this.expireLease(transition.ownerId, transition.fencingToken, nowMs);
+      return this.requireRun(transition.runId);
+    }).immediate();
+  }
+  cancelRun(runId, now) {
+    const nowMs = parseEvolutionTimestamp(now);
+    return this.database.transaction(() => {
+      const current = this.requireRunRow(runId);
+      if (EVOLUTION_TERMINAL_STAGES.includes(current.stage)) {
+        return toRun(current);
+      }
+      this.database.prepare(
+        `UPDATE evolution_runs
+             SET stage = 'cancelled', outcome = 'cancelled',
+                 updated_at_ms = ?, completed_at_ms = ?,
+                 owner_id = NULL, fencing_token = NULL
+             WHERE run_id = ?`
+      ).run(nowMs, nowMs, runId);
+      if (current.owner_id && current.fencing_token) {
+        this.expireLease(current.owner_id, current.fencing_token, nowMs);
+      }
+      return this.requireRun(runId);
+    }).immediate();
+  }
+  recoverExpiredRuns(now) {
+    return this.database.transaction(
+      () => this.recoverExpiredRunsAt(parseEvolutionTimestamp(now))
+    ).immediate();
+  }
+  putSchedule(schedule) {
+    this.database.prepare(
+      `INSERT INTO evolution_schedules (
+          schedule_id, learning_scope_id, enabled, updated_at_ms, payload_json
+        ) VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT(schedule_id) DO UPDATE SET
+          learning_scope_id = excluded.learning_scope_id,
+          enabled = excluded.enabled,
+          updated_at_ms = excluded.updated_at_ms,
+          payload_json = excluded.payload_json
+        WHERE excluded.updated_at_ms >= evolution_schedules.updated_at_ms`
+    ).run(
+      schedule.scheduleId,
+      schedule.learningScopeId,
+      schedule.enabled ? 1 : 0,
+      parseEvolutionTimestamp(schedule.updatedAt),
+      JSON.stringify(schedule)
+    );
+  }
+  getSchedule(scheduleId) {
+    const row = this.database.prepare(
+      "SELECT payload_json FROM evolution_schedules WHERE schedule_id = ?"
+    ).get(scheduleId);
+    return row ? JSON.parse(row.payload_json) : null;
+  }
+  listSchedules(learningScopeId) {
+    const rows = learningScopeId ? this.database.prepare(
+      `SELECT payload_json FROM evolution_schedules
+             WHERE learning_scope_id = ? ORDER BY updated_at_ms DESC`
+    ).all(learningScopeId) : this.database.prepare(
+      "SELECT payload_json FROM evolution_schedules ORDER BY updated_at_ms DESC"
+    ).all();
+    return rows.map((row) => JSON.parse(row.payload_json));
+  }
+  materializeDueSchedule(params) {
+    const nowMs = parseEvolutionTimestamp(params.now);
+    return this.database.transaction(() => {
+      const row = this.database.prepare(
+        "SELECT payload_json FROM evolution_schedules WHERE schedule_id = ?"
+      ).get(params.scheduleId);
+      if (!row) return false;
+      const current = JSON.parse(row.payload_json);
+      if (!current.enabled || current.nextDueAt !== params.expectedNextDueAt || parseEvolutionTimestamp(params.expectedNextDueAt) > nowMs) {
+        return false;
+      }
+      assertScheduleMaterialization(current, params);
+      this.createRun(params.run);
+      this.database.prepare(
+        `UPDATE evolution_schedules
+             SET learning_scope_id = ?, enabled = ?,
+                 updated_at_ms = ?, payload_json = ?
+             WHERE schedule_id = ?`
+      ).run(
+        params.nextSchedule.learningScopeId,
+        params.nextSchedule.enabled ? 1 : 0,
+        parseEvolutionTimestamp(params.nextSchedule.updatedAt),
+        JSON.stringify(params.nextSchedule),
+        params.scheduleId
+      );
+      return true;
+    }).immediate();
+  }
+  deleteSchedule(scheduleId) {
+    return this.database.prepare("DELETE FROM evolution_schedules WHERE schedule_id = ?").run(scheduleId).changes === 1;
+  }
+  getWatermark(learningScopeId, source) {
+    const row = this.database.prepare(
+      `SELECT value, run_id, updated_at_ms FROM evolution_watermarks
+         WHERE learning_scope_id = ? AND source = ?`
+    ).get(learningScopeId, source);
+    return row ? {
+      learningScopeId,
+      source,
+      value: row.value,
+      runId: row.run_id,
+      updatedAt: toIso(row.updated_at_ms)
+    } : null;
+  }
+  putWatermark(params) {
+    const nowMs = parseEvolutionTimestamp(params.now);
+    this.database.transaction(() => {
+      this.assertLease(params.ownerId, params.fencingToken, nowMs);
+      const run = this.requireRunRow(params.watermark.runId);
+      if (run.stage !== "validating" || run.owner_id !== params.ownerId || run.fencing_token !== params.fencingToken || run.learning_scope_id !== params.watermark.learningScopeId) {
+        throw new Error("evolution_watermark_fence_mismatch");
+      }
+      this.database.prepare(
+        `INSERT INTO evolution_watermarks (
+              learning_scope_id, source, value, run_id, updated_at_ms
+            ) VALUES (?, ?, ?, ?, ?)
+            ON CONFLICT(learning_scope_id, source) DO UPDATE SET
+              value = excluded.value,
+              run_id = excluded.run_id,
+              updated_at_ms = excluded.updated_at_ms`
+      ).run(
+        params.watermark.learningScopeId,
+        params.watermark.source,
+        params.watermark.value,
+        params.watermark.runId,
+        parseEvolutionTimestamp(params.watermark.updatedAt)
+      );
+    }).immediate();
+  }
+  finalizeRun(params, commitKnowledge) {
+    const nowMs = parseEvolutionTimestamp(params.now);
+    return this.database.transaction(() => {
+      this.assertLease(params.ownerId, params.fencingToken, nowMs);
+      const current = this.requireRunRow(params.runId);
+      if (current.stage !== "validating" || current.owner_id !== params.ownerId || current.fencing_token !== params.fencingToken) {
+        throw new Error("evolution_run_finalize_fence_mismatch");
+      }
+      commitKnowledge();
+      this.database.prepare(
+        `UPDATE evolution_runs
+             SET stage = ?, outcome = ?, updated_at_ms = ?,
+                 completed_at_ms = ?, owner_id = NULL, fencing_token = NULL
+             WHERE run_id = ?`
+      ).run(params.outcome, params.outcome, nowMs, nowMs, params.runId);
+      this.expireLease(params.ownerId, params.fencingToken, nowMs);
+      return this.requireRun(params.runId);
+    }).immediate();
+  }
+  recoverExpiredRunsAt(nowMs) {
+    const result = this.database.prepare(
+      `UPDATE evolution_runs
+         SET stage = 'queued', updated_at_ms = ?,
+             owner_id = NULL, fencing_token = NULL
+         WHERE stage IN (${placeholders(EVOLUTION_ACTIVE_STAGES.length)})
+           AND (
+             owner_id IS NULL OR fencing_token IS NULL OR NOT EXISTS (
+               SELECT 1 FROM evolution_leases
+               WHERE lease_key = ? AND owner_id = evolution_runs.owner_id
+                 AND fencing_token = evolution_runs.fencing_token
+                 AND expires_at_ms > ?
+             )
+           )`
+    ).run(nowMs, ...EVOLUTION_ACTIVE_STAGES, GLOBAL_LEASE_KEY, nowMs);
+    return result.changes;
+  }
+  getLease() {
+    return this.database.prepare(
+      `SELECT owner_id, fencing_token, expires_at_ms
+           FROM evolution_leases WHERE lease_key = ?`
+    ).get(GLOBAL_LEASE_KEY) ?? null;
+  }
+  assertLease(ownerId, fencingToken, nowMs) {
+    const lease = this.getLease();
+    if (!lease || lease.owner_id !== ownerId || lease.fencing_token !== fencingToken || lease.expires_at_ms <= nowMs) {
+      throw new Error("evolution_lease_lost");
+    }
+  }
+  expireLease(ownerId, fencingToken, nowMs) {
+    this.database.prepare(
+      `UPDATE evolution_leases SET expires_at_ms = ?
+         WHERE lease_key = ? AND owner_id = ? AND fencing_token = ?`
+    ).run(nowMs, GLOBAL_LEASE_KEY, ownerId, fencingToken);
+  }
+  requireRun(runId) {
+    return toRun(this.requireRunRow(runId));
+  }
+  requireRunRow(runId) {
+    const row = this.database.prepare("SELECT * FROM evolution_runs WHERE run_id = ?").get(runId);
+    if (!row) throw new Error("evolution_run_not_found");
+    return row;
+  }
+};
+
+// backend/src/evolution/storage/knowledge-database.ts
+var EvolutionKnowledgeDatabase = class {
+  constructor(database2, foundation) {
+    this.database = database2;
+    this.foundation = foundation;
+  }
+  listCandidates() {
+    const rows = this.database.prepare(
+      `SELECT payload_json
+         FROM (
+           SELECT payload_json,
+                  ROW_NUMBER() OVER (
+                    PARTITION BY asset_id
+                    ORDER BY updated_at DESC, rowid DESC
+                  ) AS current_revision
+           FROM candidate_asset_revisions
+         )
+         WHERE current_revision = 1`
+    ).all();
+    const candidates = rows.map(
+      (row) => JSON.parse(row.payload_json)
+    );
+    if (candidates.length === 0) return [];
+    const bindings = this.database.prepare(
+      `SELECT id, payload_json FROM evolution_repository_bindings
+       WHERE kind = 'candidate' AND id IN (SELECT value FROM json_each(?))`
+    ).all(
+      JSON.stringify(candidates.map((candidate) => candidate.assetId))
+    );
+    const attributions = new Map(
+      bindings.map((row) => [
+        row.id,
+        JSON.parse(row.payload_json)
+      ])
+    );
+    return candidates.map((candidate) => {
+      const attribution = attributions.get(candidate.assetId);
+      return attribution ? { ...candidate, attribution } : candidate;
+    });
+  }
+  putCandidate(candidate) {
+    this.database.prepare(
+      `INSERT OR IGNORE INTO candidate_asset_revisions
+          (revision_id, asset_id, learning_scope_id, updated_at, payload_json)
+         VALUES (?, ?, ?, ?, ?)`
+    ).run(
+      candidate.revisionId,
+      candidate.assetId,
+      candidate.learningScopeId,
+      candidate.updatedAt,
+      JSON.stringify(candidate)
+    );
+  }
+  putInsightRevision(params) {
+    this.database.transaction(() => this.insertInsightRevision(params)).immediate();
+  }
+  insertInsightRevision(params) {
+    const current = this.database.prepare(
+      `SELECT insight_id FROM insights
+         WHERE learning_scope_id = ? AND topic_key = ?`
+    ).get(params.insight.learningScopeId, params.insight.topicKey);
+    if (current && current.insight_id !== params.insight.insightId) {
+      throw new Error("evolution_insight_identity_conflict");
+    }
+    if (!current) {
+      this.database.prepare(
+        `INSERT INTO insights (
+            insight_id, learning_scope_id, topic_key, current_revision_id,
+            created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(
+        params.insight.insightId,
+        params.insight.learningScopeId,
+        params.insight.topicKey,
+        params.revision.revisionId,
+        params.insight.createdAt,
+        params.insight.updatedAt
+      );
+    }
+    const revisionPayload = JSON.stringify(params.revision);
+    insertImmutable(this.database, {
+      table: "insight_revisions",
+      idColumn: "revision_id",
+      id: params.revision.revisionId,
+      payload: revisionPayload,
+      insert: () => this.database.prepare(
+        `INSERT INTO insight_revisions (
+              revision_id, insight_id, run_id, created_at, payload_json
+            ) VALUES (?, ?, ?, ?, ?)`
+      ).run(
+        params.revision.revisionId,
+        params.revision.insightId,
+        params.revision.runId,
+        params.revision.createdAt,
+        revisionPayload
+      )
+    });
+    for (const edge of params.contributionEdges) {
+      const payload = JSON.stringify(edge);
+      insertImmutable(this.database, {
+        table: "contribution_edges",
+        idColumn: "edge_id",
+        id: edge.edgeId,
+        payload,
+        insert: () => this.database.prepare(
+          `INSERT INTO contribution_edges (
+                edge_id, insight_revision_id, evidence_id,
+                availability, created_at, payload_json
+              ) VALUES (?, ?, ?, ?, ?, ?)`
+        ).run(
+          edge.edgeId,
+          edge.insightRevisionId,
+          edge.evidenceId,
+          edge.availability,
+          edge.createdAt,
+          payload
+        )
+      });
+    }
+    this.database.prepare(
+      `UPDATE insights
+         SET current_revision_id = ?, updated_at = ?
+         WHERE insight_id = ? AND updated_at <= ?
+           AND (? IS NULL OR current_revision_id = ?)`
+    ).run(
+      params.revision.revisionId,
+      params.insight.updatedAt,
+      params.insight.insightId,
+      params.insight.updatedAt,
+      params.previousRevisionId ?? null,
+      params.previousRevisionId ?? null
+    );
+  }
+  listInsights(learningScopeId) {
+    const rows = learningScopeId ? this.database.prepare(
+      `SELECT * FROM insights
+             WHERE learning_scope_id = ? ORDER BY updated_at DESC`
+    ).all(learningScopeId) : this.database.prepare("SELECT * FROM insights ORDER BY updated_at DESC").all();
+    return rows.map((row) => this.toInsight(row));
+  }
+  getInsight(insightId) {
+    const row = this.database.prepare("SELECT * FROM insights WHERE insight_id = ?").get(insightId);
+    return row ? this.toInsight(row) : null;
+  }
+  listInsightRevisionsByRun(runId) {
+    return this.readPayloadRows(
+      `SELECT payload_json FROM insight_revisions
+       WHERE run_id = ? ORDER BY created_at, revision_id`,
+      runId
+    );
+  }
+  listEvidenceDependencies() {
+    const candidates = this.listCandidates();
+    const candidatesByRevision = /* @__PURE__ */ new Map();
+    for (const candidate of candidates) {
+      const group = candidatesByRevision.get(candidate.insightRevisionId) ?? [];
+      group.push(candidate);
+      candidatesByRevision.set(candidate.insightRevisionId, group);
+    }
+    const insights = this.database.prepare("SELECT * FROM insights ORDER BY updated_at DESC").all();
+    if (insights.length === 0) return [];
+    const revisionIds = [
+      .../* @__PURE__ */ new Set([
+        ...insights.map((insight) => insight.current_revision_id),
+        ...candidatesByRevision.keys()
+      ])
+    ];
+    const rows = this.database.prepare(
+      `SELECT insight_id, payload_json FROM insight_revisions
+       WHERE revision_id IN (SELECT value FROM json_each(?))
+       ORDER BY created_at, revision_id`
+    ).all(JSON.stringify(revisionIds));
+    const revisionsByInsight = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const group = revisionsByInsight.get(row.insight_id) ?? [];
+      group.push(JSON.parse(row.payload_json));
+      revisionsByInsight.set(row.insight_id, group);
+    }
+    const dependencies = insights.flatMap(
+      (insight) => (revisionsByInsight.get(insight.insight_id) ?? []).filter(
+        (revision) => revision.insightId === insight.insight_id && (revision.revisionId === insight.current_revision_id || candidatesByRevision.has(revision.revisionId))
+      ).map((revision) => ({
+        insight: {
+          insightId: insight.insight_id,
+          learningScopeId: insight.learning_scope_id,
+          topicKey: insight.topic_key,
+          currentRevisionId: insight.current_revision_id,
+          createdAt: insight.created_at,
+          updatedAt: insight.updated_at
+        },
+        revision,
+        candidates: candidatesByRevision.get(revision.revisionId) ?? []
+      }))
+    );
+    if (dependencies.length === 0) return [];
+    const edges = this.database.prepare(
+      `SELECT insight_revision_id, payload_json FROM contribution_edges
+       WHERE insight_revision_id IN (SELECT value FROM json_each(?)) ORDER BY edge_id`
+    ).all(
+      JSON.stringify(dependencies.map((item) => item.revision.revisionId))
+    );
+    const edgesByRevision = /* @__PURE__ */ new Map();
+    for (const row of edges) {
+      const group = edgesByRevision.get(row.insight_revision_id) ?? [];
+      group.push(JSON.parse(row.payload_json));
+      edgesByRevision.set(row.insight_revision_id, group);
+    }
+    return dependencies.map((dependency) => ({
+      ...dependency,
+      contributionEdges: edgesByRevision.get(dependency.revision.revisionId) ?? []
+    }));
+  }
+  applyEvidenceReconciliation(reconciliation) {
+    this.database.transaction(() => {
+      for (const insight of reconciliation.insights) {
+        this.insertInsightRevision(insight);
+      }
+      const revisionIds = new Set(
+        reconciliation.insights.map((item) => item.revision.revisionId)
+      );
+      for (const candidate of reconciliation.candidates) {
+        if (!revisionIds.has(candidate.insightRevisionId)) {
+          throw new Error("evolution_reconciled_candidate_revision_mismatch");
+        }
+        this.putCandidate(candidate);
+      }
+    }).immediate();
+  }
+  commitRunKnowledge(params) {
+    if (params.outcome === "no_material_novelty" && (params.insights.length > 0 || params.candidates.length > 0)) {
+      throw new Error("evolution_no_material_novelty_has_output");
+    }
+    return this.foundation.finalizeRun(params, () => {
+      for (const insight of params.insights) {
+        if (insight.revision.runId !== params.runId) {
+          throw new Error("evolution_insight_run_mismatch");
+        }
+        this.insertInsightRevision(insight);
+      }
+      const committedRevisionIds = new Set(
+        params.insights.map((item) => item.revision.revisionId)
+      );
+      for (const candidate of params.candidates) {
+        if (!committedRevisionIds.has(candidate.insightRevisionId)) {
+          throw new Error("evolution_candidate_revision_mismatch");
+        }
+        this.putCandidate(candidate);
+      }
+      if (params.watermark) {
+        if (params.watermark.runId !== params.runId) {
+          throw new Error("evolution_watermark_run_mismatch");
+        }
+        this.database.prepare(
+          `INSERT INTO evolution_watermarks (
+              learning_scope_id, source, value, run_id, updated_at_ms
+            ) VALUES (?, ?, ?, ?, ?)
+            ON CONFLICT(learning_scope_id, source) DO UPDATE SET
+              value = excluded.value,
+              run_id = excluded.run_id,
+              updated_at_ms = excluded.updated_at_ms`
+        ).run(
+          params.watermark.learningScopeId,
+          params.watermark.source,
+          params.watermark.value,
+          params.watermark.runId,
+          Date.parse(params.watermark.updatedAt)
+        );
+      }
+    });
+  }
+  toInsight(row) {
+    const membership = this.database.prepare(
+      "SELECT canonical_insight_id FROM evolution_topic_lineage WHERE legacy_insight_id=?"
+    ).get(row.insight_id);
+    const members = membership ? this.database.prepare(
+      "SELECT legacy_insight_id, status FROM evolution_topic_lineage WHERE canonical_insight_id=? ORDER BY legacy_insight_id"
+    ).all(membership.canonical_insight_id) : [];
+    const attribution = readRepositoryAttribution(
+      this.database,
+      "insight",
+      row.insight_id
+    );
+    return {
+      ...attribution ? { attribution } : {},
+      ...membership ? {
+        lineage: {
+          canonicalInsightId: membership.canonical_insight_id,
+          memberIds: members.map((member) => member.legacy_insight_id),
+          status: members.some((member) => member.status === "contested") ? "contested" : "resolved"
+        }
+      } : {},
+      insightId: row.insight_id,
+      learningScopeId: row.learning_scope_id,
+      .../^[a-f0-9]{64}$/u.test(row.learning_scope_id) ? { repositoryId: row.learning_scope_id } : {},
+      topicKey: row.topic_key,
+      currentRevisionId: row.current_revision_id,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      revisions: this.readPayloadRows(
+        `SELECT payload_json FROM insight_revisions
+         WHERE insight_id = ? OR insight_id IN (
+           SELECT legacy_insight_id FROM evolution_topic_lineage WHERE canonical_insight_id = ?
+         ) ORDER BY created_at, revision_id`,
+        row.insight_id,
+        row.insight_id
+      )
+    };
+  }
+  readPayloadRows(sql, ...values) {
+    const rows = this.database.prepare(sql).all(...values);
+    return rows.map((row) => JSON.parse(row.payload_json));
+  }
+};
+
+// backend/src/evolution/storage/migrations.ts
+var SCHEMA_VERSION = 6;
+var MINIMUM_WRITER_VERSION = 2;
+function migrateEvolutionDatabase(database2) {
+  database2.exec(`
+    CREATE TABLE IF NOT EXISTS evolution_metadata (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    )
+  `);
+  assertCompatibleWriter(database2);
+  const version = database2.prepare("SELECT value FROM evolution_metadata WHERE key = ?").get("schemaVersion");
+  if (version && Number(version.value) < 6) {
+    for (const table of [
+      "evolution_runs",
+      "evolution_schedules",
+      "insights",
+      "candidate_asset_revisions",
+      "evolution_policies",
+      "evolution_watermarks"
+    ]) {
+      if (!database2.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(table))
+        continue;
+      if (database2.prepare(`SELECT 1 FROM ${table} LIMIT 1`).get())
+        throw new Error("evolution_repository_migration_required");
+    }
+  }
+  const state = database2.prepare("SELECT value FROM evolution_metadata WHERE key = ?").get("repositoryMigrationState");
+  if (state && state.value !== "complete" || version && Number(version.value) >= 6 && !state)
+    throw new Error("evolution_repository_migration_incomplete");
+  database2.transaction(() => {
+    database2.exec(`
+        CREATE TABLE IF NOT EXISTS candidate_asset_revisions (
+          revision_id TEXT PRIMARY KEY,
+          asset_id TEXT NOT NULL,
+          learning_scope_id TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          payload_json TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS candidate_asset_scope_idx
+          ON candidate_asset_revisions (learning_scope_id, asset_id, updated_at);
+
+        CREATE TABLE IF NOT EXISTS evolution_policies (
+          learning_scope_id TEXT PRIMARY KEY,
+          revision INTEGER NOT NULL,
+          payload_json TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS runtime_traces (
+          trace_id TEXT PRIMARY KEY,
+          run_id TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          payload_json TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS runtime_trace_run_idx
+          ON runtime_traces (run_id, created_at);
+
+        CREATE TABLE IF NOT EXISTS runtime_trace_events (
+          event_id TEXT PRIMARY KEY,
+          trace_id TEXT NOT NULL
+            REFERENCES runtime_traces(trace_id) ON DELETE CASCADE,
+          at TEXT NOT NULL,
+          payload_json TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS runtime_trace_event_trace_idx
+          ON runtime_trace_events (trace_id, at);
+
+        CREATE TABLE IF NOT EXISTS evolution_runs (
+          run_id TEXT PRIMARY KEY,
+          learning_scope_id TEXT NOT NULL,
+          trigger_type TEXT NOT NULL,
+          priority INTEGER NOT NULL,
+          trigger_json TEXT NOT NULL,
+          profile TEXT NOT NULL,
+          provider_policy TEXT NOT NULL,
+          budget_json TEXT NOT NULL,
+          data_range_json TEXT NOT NULL,
+          stage TEXT NOT NULL,
+          outcome TEXT,
+          created_at_ms INTEGER NOT NULL,
+          updated_at_ms INTEGER NOT NULL,
+          started_at_ms INTEGER,
+          completed_at_ms INTEGER,
+          attempt INTEGER NOT NULL,
+          owner_id TEXT,
+          fencing_token INTEGER
+        );
+        CREATE INDEX IF NOT EXISTS evolution_run_queue_idx
+          ON evolution_runs (stage, priority, created_at_ms);
+        CREATE INDEX IF NOT EXISTS evolution_run_scope_idx
+          ON evolution_runs (learning_scope_id, created_at_ms DESC);
+
+        CREATE TABLE IF NOT EXISTS evolution_leases (
+          lease_key TEXT PRIMARY KEY,
+          owner_id TEXT NOT NULL,
+          fencing_token INTEGER NOT NULL,
+          acquired_at_ms INTEGER NOT NULL,
+          expires_at_ms INTEGER NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS evolution_schedules (
+          schedule_id TEXT PRIMARY KEY,
+          learning_scope_id TEXT NOT NULL,
+          enabled INTEGER NOT NULL,
+          updated_at_ms INTEGER NOT NULL,
+          payload_json TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS evolution_schedule_scope_idx
+          ON evolution_schedules (learning_scope_id, updated_at_ms DESC);
+
+        CREATE TABLE IF NOT EXISTS evolution_watermarks (
+          learning_scope_id TEXT NOT NULL,
+          source TEXT NOT NULL,
+          value TEXT NOT NULL,
+          run_id TEXT NOT NULL,
+          updated_at_ms INTEGER NOT NULL,
+          PRIMARY KEY (learning_scope_id, source)
+        );
+
+        CREATE TABLE IF NOT EXISTS context_packs (
+          context_pack_id TEXT PRIMARY KEY,
+          run_id TEXT NOT NULL UNIQUE,
+          learning_scope_id TEXT NOT NULL,
+          digest TEXT NOT NULL,
+          created_at_ms INTEGER NOT NULL,
+          manifest_json TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS context_pack_scope_idx
+          ON context_packs (learning_scope_id, created_at_ms DESC);
+        CREATE INDEX IF NOT EXISTS context_pack_digest_idx
+          ON context_packs (digest);
+
+        CREATE TABLE IF NOT EXISTS context_pack_sources (
+          context_pack_id TEXT NOT NULL
+            REFERENCES context_packs(context_pack_id) ON DELETE CASCADE,
+          source_id TEXT NOT NULL,
+          source TEXT NOT NULL,
+          boundary_json TEXT NOT NULL,
+          PRIMARY KEY (context_pack_id, source_id)
+        );
+        CREATE TRIGGER IF NOT EXISTS context_packs_immutable_update
+          BEFORE UPDATE ON context_packs
+          BEGIN
+            SELECT RAISE(ABORT, 'evolution_context_pack_immutable');
+          END;
+        CREATE TRIGGER IF NOT EXISTS context_pack_sources_immutable_update
+          BEFORE UPDATE ON context_pack_sources
+          BEGIN
+            SELECT RAISE(ABORT, 'evolution_context_pack_source_immutable');
+          END;
+
+        CREATE TABLE IF NOT EXISTS trace_segments (
+          segment_id TEXT PRIMARY KEY,
+          run_id TEXT NOT NULL,
+          learning_scope_id TEXT NOT NULL,
+          sequence INTEGER NOT NULL,
+          payload_json TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS trace_segment_run_idx
+          ON trace_segments (run_id, sequence);
+
+        CREATE TABLE IF NOT EXISTS episodes (
+          episode_id TEXT PRIMARY KEY,
+          run_id TEXT NOT NULL,
+          learning_scope_id TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          payload_json TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS episode_run_idx
+          ON episodes (run_id, created_at);
+
+        CREATE TABLE IF NOT EXISTS analysis_reports (
+          report_id TEXT PRIMARY KEY,
+          run_id TEXT NOT NULL,
+          attempt_number INTEGER NOT NULL,
+          role TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          payload_json TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS analysis_report_run_idx
+          ON analysis_reports (run_id, attempt_number, created_at);
+
+        CREATE TABLE IF NOT EXISTS evolution_run_attempts (
+          attempt_id TEXT PRIMARY KEY,
+          run_id TEXT NOT NULL,
+          attempt_number INTEGER NOT NULL,
+          role TEXT NOT NULL,
+          provider TEXT NOT NULL,
+          status TEXT NOT NULL,
+          started_at TEXT NOT NULL,
+          completed_at TEXT,
+          payload_json TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS evolution_run_attempt_run_idx
+          ON evolution_run_attempts (run_id, attempt_number, started_at);
+
+        CREATE TABLE IF NOT EXISTS claims (
+          claim_id TEXT PRIMARY KEY,
+          run_id TEXT NOT NULL,
+          learning_scope_id TEXT NOT NULL,
+          topic_key TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          payload_json TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS claim_run_idx
+          ON claims (run_id, topic_key);
+
+        CREATE TABLE IF NOT EXISTS claim_novelty (
+          claim_id TEXT PRIMARY KEY
+            REFERENCES claims(claim_id) ON DELETE CASCADE,
+          run_id TEXT NOT NULL,
+          novelty TEXT NOT NULL,
+          payload_json TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS claim_novelty_run_idx
+          ON claim_novelty (run_id, novelty);
+
+        CREATE TABLE IF NOT EXISTS insights (
+          insight_id TEXT PRIMARY KEY,
+          learning_scope_id TEXT NOT NULL,
+          topic_key TEXT NOT NULL,
+          current_revision_id TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          UNIQUE (learning_scope_id, topic_key)
+        );
+        CREATE INDEX IF NOT EXISTS insight_scope_idx
+          ON insights (learning_scope_id, updated_at DESC);
+
+        CREATE TABLE IF NOT EXISTS insight_revisions (
+          revision_id TEXT PRIMARY KEY,
+          insight_id TEXT NOT NULL
+            REFERENCES insights(insight_id) ON DELETE CASCADE,
+          run_id TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          payload_json TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS insight_revision_insight_idx
+          ON insight_revisions (insight_id, created_at);
+        CREATE INDEX IF NOT EXISTS insight_revision_run_idx
+          ON insight_revisions (run_id, created_at);
+
+        CREATE TABLE IF NOT EXISTS contribution_edges (
+          edge_id TEXT PRIMARY KEY,
+          insight_revision_id TEXT NOT NULL
+            REFERENCES insight_revisions(revision_id) ON DELETE CASCADE,
+          evidence_id TEXT NOT NULL,
+          availability TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          payload_json TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS contribution_edge_revision_idx
+          ON contribution_edges (insight_revision_id, evidence_id);
+
+        CREATE TRIGGER IF NOT EXISTS trace_segments_immutable_update
+          BEFORE UPDATE ON trace_segments
+          BEGIN
+            SELECT RAISE(ABORT, 'evolution_trace_segment_immutable');
+          END;
+        CREATE TRIGGER IF NOT EXISTS episodes_immutable_update
+          BEFORE UPDATE ON episodes
+          BEGIN
+            SELECT RAISE(ABORT, 'evolution_episode_immutable');
+          END;
+        CREATE TRIGGER IF NOT EXISTS analysis_reports_immutable_update
+          BEFORE UPDATE ON analysis_reports
+          BEGIN
+            SELECT RAISE(ABORT, 'evolution_analysis_report_immutable');
+          END;
+        CREATE TRIGGER IF NOT EXISTS claims_immutable_update
+          BEFORE UPDATE ON claims
+          BEGIN
+            SELECT RAISE(ABORT, 'evolution_claim_immutable');
+          END;
+        CREATE TRIGGER IF NOT EXISTS claim_novelty_immutable_update
+          BEFORE UPDATE ON claim_novelty
+          BEGIN
+            SELECT RAISE(ABORT, 'evolution_claim_novelty_immutable');
+          END;
+        CREATE TRIGGER IF NOT EXISTS insight_revisions_immutable_update
+          BEFORE UPDATE ON insight_revisions
+          BEGIN
+            SELECT RAISE(ABORT, 'evolution_insight_revision_immutable');
+          END;
+        CREATE TRIGGER IF NOT EXISTS contribution_edges_immutable_update
+          BEFORE UPDATE ON contribution_edges
+          BEGIN
+            SELECT RAISE(ABORT, 'evolution_contribution_edge_immutable');
+          END;
+      `);
+    initializeEvolutionRepositories(database2);
+    database2.prepare(
+      "INSERT INTO evolution_metadata(key,value) VALUES (?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value"
+    ).run("repositoryMigrationState", "complete");
+    database2.prepare(
+      `INSERT INTO evolution_metadata (key, value) VALUES (?, ?)
+           ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+    ).run("schemaVersion", String(SCHEMA_VERSION));
+    database2.prepare(
+      "INSERT INTO evolution_metadata (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+    ).run("minimumWriterVersion", String(MINIMUM_WRITER_VERSION));
+  }).immediate();
+}
+function assertCompatibleWriter(database2) {
+  const minimumWriterVersion = database2.prepare("SELECT value FROM evolution_metadata WHERE key = ?").get("minimumWriterVersion");
+  if (!minimumWriterVersion) return;
+  const parsed = Number(minimumWriterVersion.value);
+  if (!Number.isInteger(parsed) || parsed > MINIMUM_WRITER_VERSION) {
+    throw new Error("evolution_schema_incompatible");
+  }
+}
+
+// backend/src/evolution/storage/database.ts
+var EvolutionActivationDatabase = class {
+  database;
+  foundation;
+  artifactReads;
+  artifacts;
+  knowledge;
+  constructor(databasePath) {
+    (0, import_node_fs.mkdirSync)(import_node_path.default.dirname(databasePath), { recursive: true, mode: 448 });
+    this.database = new import_better_sqlite3.default(databasePath);
+    this.database.pragma("journal_mode = WAL");
+    this.database.pragma("busy_timeout = 5000");
+    this.database.pragma("foreign_keys = ON");
+    try {
+      migrateEvolutionDatabase(this.database);
+    } catch (error) {
+      this.database.close();
+      throw error;
+    }
+    this.foundation = new EvolutionFoundationDatabase(this.database);
+    this.artifacts = new EvolutionArtifactDatabase(this.database);
+    this.artifactReads = new EvolutionArtifactReads(this.database);
+    this.knowledge = new EvolutionKnowledgeDatabase(
+      this.database,
+      this.foundation
+    );
+  }
+  repository(command) {
+    return executeRepositoryCommand(this.database, this.foundation, command);
+  }
+  getPolicy(learningScopeId) {
+    const row = this.database.prepare(
+      "SELECT payload_json FROM evolution_policies WHERE learning_scope_id = ?"
+    ).get(learningScopeId);
+    return row ? JSON.parse(row.payload_json) : null;
+  }
+  putPolicy(policy) {
+    const result = this.database.prepare(
+      `INSERT INTO evolution_policies (learning_scope_id, revision, payload_json)
+         VALUES (?, ?, ?)
+         ON CONFLICT(learning_scope_id) DO UPDATE SET
+           revision = excluded.revision,
+           payload_json = excluded.payload_json
+         WHERE excluded.revision > evolution_policies.revision`
+    ).run(policy.learningScopeId, policy.revision, JSON.stringify(policy));
+    if (result.changes !== 1) {
+      throw new Error("evolution_policy_revision_conflict");
+    }
+  }
+  listCandidates() {
+    return this.knowledge.listCandidates();
+  }
+  putCandidate(candidate) {
+    this.knowledge.putCandidate(candidate);
+  }
+  putRuntimeTrace(trace) {
+    this.artifacts.putRuntimeTrace(trace);
+  }
+  appendRuntimeTraceEvent(event) {
+    this.artifacts.appendRuntimeTraceEvent(event);
+  }
+  getRuntimeTrace(traceId) {
+    return this.artifacts.getRuntimeTrace(traceId);
+  }
+  listRuntimeTraces(runId) {
+    return this.artifacts.listRuntimeTraces(runId);
+  }
+  listRecentRuntimeTraces(learningScopeId, limit) {
+    return this.artifacts.listRecentRuntimeTraces(learningScopeId, limit);
+  }
+  getArtifactOverview(runId) {
+    return this.artifactReads.overview(runId);
+  }
+  getArtifactPage(runId, query) {
+    return this.artifactReads.page(runId, query);
+  }
+  putContextPack(manifest) {
+    this.artifacts.putContextPack(manifest);
+  }
+  getContextPack(contextPackId) {
+    return this.artifacts.getContextPack(contextPackId);
+  }
+  getContextPackByRun(runId) {
+    return this.artifacts.getContextPackByRun(runId);
+  }
+  putTraceSegments(segments) {
+    this.artifacts.putTraceSegments(segments);
+  }
+  listTraceSegments(runId) {
+    return this.artifacts.listTraceSegments(runId);
+  }
+  putEpisodes(episodes) {
+    this.artifacts.putEpisodes(episodes);
+  }
+  listEpisodes(runId) {
+    return this.artifacts.listEpisodes(runId);
+  }
+  putAnalysisReport(report) {
+    this.artifacts.putAnalysisReport(report);
+  }
+  listAnalysisReports(runId) {
+    return this.artifacts.listAnalysisReports(runId);
+  }
+  putRunAttempt(attempt) {
+    this.artifacts.putRunAttempt(attempt);
+  }
+  listRunAttempts(runId) {
+    return this.artifacts.listRunAttempts(runId);
+  }
+  putClaims(claims) {
+    this.artifacts.putClaims(claims);
+  }
+  listClaims(runId) {
+    return this.artifacts.listClaims(runId);
+  }
+  putClaimNovelty(items) {
+    this.artifacts.putClaimNovelty(items);
+  }
+  listClaimNovelty(runId) {
+    return this.artifacts.listClaimNovelty(runId);
+  }
+  putInsightRevision(params) {
+    this.knowledge.putInsightRevision(params);
+  }
+  listInsights(learningScopeId) {
+    return this.knowledge.listInsights(learningScopeId);
+  }
+  getInsight(insightId) {
+    return this.knowledge.getInsight(insightId);
+  }
+  listInsightRevisionsByRun(runId) {
+    return this.knowledge.listInsightRevisionsByRun(runId);
+  }
+  listEvidenceDependencies() {
+    return this.knowledge.listEvidenceDependencies();
+  }
+  applyEvidenceReconciliation(reconciliation) {
+    this.knowledge.applyEvidenceReconciliation(reconciliation);
+  }
+  commitRunKnowledge(params) {
+    return this.knowledge.commitRunKnowledge(params);
+  }
+  finishRunningAttempts(runId, status, completedAt) {
+    this.database.prepare(
+      `UPDATE evolution_run_attempts
+         SET status = ?, completed_at = ?,
+             payload_json = json_set(
+               payload_json,
+               '$.status', ?,
+               '$.completedAt', ?,
+               '$.errorCode', ?
+             )
+         WHERE run_id = ? AND status = 'running'`
+    ).run(status, completedAt, status, completedAt, "run_cancelled", runId);
+  }
+  createRun(run) {
+    this.foundation.createRun(run);
+  }
+  getRun(runId) {
+    return this.foundation.getRun(runId);
+  }
+  listRuns(query) {
+    return this.foundation.listRuns(query);
+  }
+  claimNextRun(params) {
+    return this.foundation.claimNextRun(params);
+  }
+  heartbeatRunClaim(params) {
+    return this.foundation.heartbeatRunClaim(params);
+  }
+  transitionRun(transition) {
+    return this.foundation.transitionRun(transition);
+  }
+  cancelRun(runId, now) {
+    const run = this.foundation.cancelRun(runId, now);
+    this.finishRunningAttempts(runId, "cancelled", now);
+    return run;
+  }
+  recoverExpiredRuns(now) {
+    const recovered = this.foundation.recoverExpiredRuns(now);
+    if (recovered > 0) {
+      this.database.prepare(
+        `UPDATE evolution_run_attempts
+           SET status = 'abandoned', completed_at = ?,
+               payload_json = json_set(
+                 payload_json,
+                 '$.status', 'abandoned',
+                 '$.completedAt', ?,
+                 '$.errorCode', 'backend_recovered_unknown_call'
+               )
+           WHERE status = 'running'
+             AND run_id IN (
+               SELECT run_id FROM evolution_runs WHERE stage = 'queued'
+             )`
+      ).run(now, now);
+    }
+    return recovered;
+  }
+  putSchedule(schedule) {
+    this.foundation.putSchedule(schedule);
+  }
+  getSchedule(scheduleId) {
+    return this.foundation.getSchedule(scheduleId);
+  }
+  listSchedules(learningScopeId) {
+    return this.foundation.listSchedules(learningScopeId);
+  }
+  materializeDueSchedule(params) {
+    return this.foundation.materializeDueSchedule(params);
+  }
+  deleteSchedule(scheduleId) {
+    return this.foundation.deleteSchedule(scheduleId);
+  }
+  getWatermark(learningScopeId, source) {
+    return this.foundation.getWatermark(learningScopeId, source);
+  }
+  putWatermark(params) {
+    this.foundation.putWatermark(params);
+  }
+  integrity() {
+    const result = this.database.pragma("quick_check");
+    return result.every((row) => row.quick_check === "ok");
+  }
+  close() {
+    this.database.close();
+  }
+};
+
+// backend/src/evolution/storage/sqlite-worker.ts
+if (!import_node_worker_threads.parentPort) throw new Error("evolution_worker_parent_port_required");
+var port = import_node_worker_threads.parentPort;
+var database = new EvolutionActivationDatabase(
+  import_node_worker_threads.workerData.databasePath
+);
+function execute(command) {
+  switch (command.op) {
+    case "repository":
+      return database.repository(command.command);
+    case "list-candidates":
+      return database.listCandidates();
+    case "put-candidate":
+      database.putCandidate(command.candidate);
+      return true;
+    case "get-policy":
+      return database.getPolicy(command.learningScopeId);
+    case "put-policy":
+      database.putPolicy(command.policy);
+      return true;
+    case "put-trace":
+      database.putRuntimeTrace(command.trace);
+      return true;
+    case "append-trace-event":
+      database.appendRuntimeTraceEvent(command.event);
+      return true;
+    case "get-trace":
+      return database.getRuntimeTrace(command.traceId);
+    case "list-traces":
+      return database.listRuntimeTraces(command.runId);
+    case "list-recent-traces":
+      return database.listRecentRuntimeTraces(
+        command.learningScopeId,
+        command.limit
+      );
+    case "artifact-overview":
+      return database.getArtifactOverview(command.runId);
+    case "artifact-page":
+      return database.getArtifactPage(command.runId, command.query);
+    case "put-context-pack":
+      database.putContextPack(command.manifest);
+      return true;
+    case "get-context-pack":
+      return database.getContextPack(command.contextPackId);
+    case "get-context-pack-by-run":
+      return database.getContextPackByRun(command.runId);
+    case "put-trace-segments":
+      database.putTraceSegments(command.segments);
+      return true;
+    case "list-trace-segments":
+      return database.listTraceSegments(command.runId);
+    case "put-episodes":
+      database.putEpisodes(command.episodes);
+      return true;
+    case "list-episodes":
+      return database.listEpisodes(command.runId);
+    case "put-analysis-report":
+      database.putAnalysisReport(command.report);
+      return true;
+    case "list-analysis-reports":
+      return database.listAnalysisReports(command.runId);
+    case "put-run-attempt":
+      database.putRunAttempt(command.attempt);
+      return true;
+    case "list-run-attempts":
+      return database.listRunAttempts(command.runId);
+    case "put-claims":
+      database.putClaims(command.claims);
+      return true;
+    case "list-claims":
+      return database.listClaims(command.runId);
+    case "put-claim-novelty":
+      database.putClaimNovelty(command.items);
+      return true;
+    case "list-claim-novelty":
+      return database.listClaimNovelty(command.runId);
+    case "put-insight-revision":
+      database.putInsightRevision(command);
+      return true;
+    case "list-insights":
+      return database.listInsights(command.learningScopeId);
+    case "get-insight":
+      return database.getInsight(command.insightId);
+    case "list-insight-revisions-by-run":
+      return database.listInsightRevisionsByRun(command.runId);
+    case "list-evidence-dependencies":
+      return database.listEvidenceDependencies();
+    case "apply-evidence-reconciliation":
+      database.applyEvidenceReconciliation(command.reconciliation);
+      return true;
+    case "commit-run-knowledge":
+      return database.commitRunKnowledge(command.params);
+    case "create-run":
+      database.createRun(command.run);
+      return true;
+    case "get-run":
+      return database.getRun(command.runId);
+    case "list-runs":
+      return database.listRuns(command.query);
+    case "claim-next-run":
+      return database.claimNextRun(command);
+    case "heartbeat-run-claim":
+      return database.heartbeatRunClaim(command);
+    case "transition-run":
+      return database.transitionRun(command.transition);
+    case "cancel-run":
+      return database.cancelRun(command.runId, command.now);
+    case "recover-expired-runs":
+      return database.recoverExpiredRuns(command.now);
+    case "put-schedule":
+      database.putSchedule(command.schedule);
+      return true;
+    case "get-schedule":
+      return database.getSchedule(command.scheduleId);
+    case "list-schedules":
+      return database.listSchedules(command.learningScopeId);
+    case "materialize-due-schedule":
+      return database.materializeDueSchedule(command.params);
+    case "delete-schedule":
+      return database.deleteSchedule(command.scheduleId);
+    case "get-watermark":
+      return database.getWatermark(command.learningScopeId, command.source);
+    case "put-watermark":
+      database.putWatermark(command);
+      return true;
+    case "integrity":
+      return database.integrity();
+    case "close":
+      database.close();
+      return true;
+  }
+}
+port.on("message", (command) => {
+  let response;
+  try {
+    response = { id: command.id, ok: true, result: execute(command) };
+  } catch (error) {
+    response = {
+      id: command.id,
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+  port.postMessage(response);
+  if (command.op === "close") port.close();
+});