panoma 0.1.9 → 0.9.0

package/app/node_modules/@panoma/db/dist/index.js

@@ -3,8 +3,12 @@ import {
   agentActivities,
   agentSessions,
   agents,
+  appJobs,
+  appWorkspaces,
+  apps,
   beliefs,
   consultations,
+  decisionEpisodes,
   decisions,
   designFingerprints,
   distributions,
@@ -13,7 +17,9 @@ import {
   familyMembers,
   launches,
   looks,
+  memoryJobs,
   modelCalls,
+  narratives,
   notes,
   observations,
   packages,
@@ -32,13 +38,187 @@ import {
   technologies,
   verdicts,
   vulnerabilities
-} from "./chunk-GRGC435V.js";
+} from "./chunk-V6TJYC6N.js";
+
+// src/apps.ts
+import { createHash, randomUUID } from "crypto";
+import { and, asc, desc, eq, gte, inArray, ne, sql } from "drizzle-orm";
+var LIVE_APP_JOBS = ["pending", "running", "cancelling"];
+var MAX_APP_SPEND_CALLS = 1e3;
+var TRANSITIONS = {
+  pending: ["running", "cancelled"],
+  running: ["done", "failed", "cancelling"],
+  cancelling: ["cancelled", "failed"],
+  cancelled: [],
+  failed: [],
+  done: []
+};
+function appJobTransition(from, to) {
+  return TRANSITIONS[from].includes(to);
+}
+function canonicalAppInput(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) return "[" + value.map(canonicalAppInput).join(",") + "]";
+  const row = value;
+  return "{" + Object.keys(row).sort().map((key) => JSON.stringify(key) + ":" + canonicalAppInput(row[key])).join(",") + "}";
+}
+function appDedupeKey(appId, identity, tool, input) {
+  return createHash("sha256").update(canonicalAppInput([appId, identity, tool, input])).digest("hex");
+}
+async function ensureApp(db, id, pkg) {
+  await db.insert(apps).values({ id, pkg }).onConflictDoNothing();
+}
+async function listApps(db) {
+  return db.select().from(apps).orderBy(asc(apps.id));
+}
+async function getApp(db, id) {
+  return (await db.select().from(apps).where(eq(apps.id, id)).limit(1))[0];
+}
+async function updateApp(db, id, patch) {
+  await db.update(apps).set({ ...patch, updatedAt: /* @__PURE__ */ new Date() }).where(eq(apps.id, id));
+}
+async function getAppJob(db, id) {
+  return (await db.select().from(appJobs).where(eq(appJobs.id, id)).limit(1))[0];
+}
+async function listAppJobs(db, options = {}) {
+  return db.select().from(appJobs).where(and(
+    options.appId === void 0 ? void 0 : eq(appJobs.appId, options.appId),
+    options.identity === void 0 ? void 0 : eq(appJobs.identity, options.identity),
+    options.statuses === void 0 ? void 0 : inArray(appJobs.status, options.statuses)
+  )).orderBy(desc(appJobs.requestedAt), desc(appJobs.id)).limit(options.limit ?? 50);
+}
+async function enqueueAppJobRow(db, input) {
+  const dedupeKey = appDedupeKey(input.appId, input.identity, input.tool, input.input);
+  return db.transaction(async (tx) => {
+    await tx.execute(sql`lock table ${appJobs} in share row exclusive mode`);
+    const [existing] = await tx.select().from(appJobs).where(and(
+      eq(appJobs.dedupeKey, dedupeKey),
+      inArray(appJobs.status, LIVE_APP_JOBS)
+    )).limit(1);
+    if (existing) return { job: existing, duplicate: true };
+    let reservedCalls = 0;
+    if (input.paid) {
+      const since = /* @__PURE__ */ new Date();
+      since.setHours(0, 0, 0, 0);
+      const [spent] = await tx.select({ n: sql`count(*)::int` }).from(modelCalls).where(and(eq(modelCalls.kind, "app"), gte(modelCalls.createdAt, since)));
+      const [held] = await tx.select({ n: sql`coalesce(sum(${appJobs.reservedCalls}), 0)::int` }).from(appJobs).where(sql`(${appJobs.status} in ('pending','running','cancelling')
+          or ${appJobs.finishedAt} >= ${since})`);
+      reservedCalls = Math.max(0, Math.floor(input.cap ?? 0) - (spent?.n ?? 0) - (held?.n ?? 0));
+      if (!reservedCalls) throw new Error("app-budget-exhausted");
+    }
+    const [job] = await tx.insert(appJobs).values({
+      id: randomUUID(),
+      appId: input.appId,
+      identity: input.identity,
+      workspaceId: input.workspaceId,
+      tool: input.tool,
+      input: input.input,
+      appVersion: input.appVersion,
+      dedupeKey,
+      reservedCalls
+    }).returning();
+    return { job, duplicate: false };
+  });
+}
+async function hasPendingAppJob(db) {
+  return (await db.select({ id: appJobs.id }).from(appJobs).where(eq(appJobs.status, "pending")).limit(1)).length > 0;
+}
+async function claimAppJob(db) {
+  return db.transaction(async (tx) => {
+    await tx.execute(sql`lock table ${appJobs} in share row exclusive mode`);
+    const running = await tx.select({ id: appJobs.id }).from(appJobs).where(inArray(appJobs.status, ["running", "cancelling"])).limit(1);
+    if (running.length) return void 0;
+    const [next] = await tx.select().from(appJobs).where(eq(appJobs.status, "pending")).orderBy(asc(appJobs.requestedAt), asc(appJobs.id)).limit(1);
+    if (!next) return void 0;
+    return (await tx.update(appJobs).set({ status: "running", startedAt: /* @__PURE__ */ new Date() }).where(eq(appJobs.id, next.id)).returning())[0];
+  });
+}
+async function transitionAppJob(db, id, from, to, patch = {}) {
+  if (!appJobTransition(from, to)) throw new Error("invalid-app-job-transition");
+  const terminal = !LIVE_APP_JOBS.includes(to);
+  const rows = await db.update(appJobs).set({
+    ...patch,
+    status: to,
+    ...terminal ? { pid: null, finishedAt: /* @__PURE__ */ new Date() } : {}
+  }).where(and(eq(appJobs.id, id), eq(appJobs.status, from))).returning({ id: appJobs.id });
+  return rows.length > 0;
+}
+async function updateAppJobProgress(db, id, progress, pid) {
+  await db.update(appJobs).set({ progress, ...pid ? { pid } : {} }).where(and(eq(appJobs.id, id), inArray(appJobs.status, ["running", "cancelling"])));
+}
+async function getAppWorkspace(db, appId, identity) {
+  return (await db.select().from(appWorkspaces).where(and(
+    eq(appWorkspaces.appId, appId),
+    eq(appWorkspaces.identity, identity)
+  )).limit(1))[0];
+}
+async function saveAppWorkspace(db, row) {
+  await db.insert(appWorkspaces).values(row).onConflictDoNothing();
+}
+async function forgetAppWorkspaces(db, appId) {
+  await db.delete(appWorkspaces).where(eq(appWorkspaces.appId, appId));
+}
+async function appProject(db, identity, projectId) {
+  const rows = await db.select({
+    id: projects.id,
+    identity: projects.identity,
+    root: projects.root,
+    slug: projects.slug,
+    name: projects.name
+  }).from(projects).where(and(
+    eq(projects.identity, identity),
+    projectId ? eq(projects.id, projectId) : void 0
+  )).limit(2);
+  if (rows.length !== 1) throw new Error(rows.length ? "ambiguous-project" : "project-not-found");
+  return rows[0];
+}
+async function revalidateAppBudget(db, job, cap) {
+  return db.transaction(async (tx) => {
+    await tx.execute(sql`lock table ${appJobs} in share row exclusive mode`);
+    const current = await getAppJob(tx, job.id);
+    if (!current) throw new Error("app-job-not-found");
+    const since = /* @__PURE__ */ new Date();
+    since.setHours(0, 0, 0, 0);
+    const [spent] = await tx.select({ n: sql`count(*)::int` }).from(modelCalls).where(and(eq(modelCalls.kind, "app"), gte(modelCalls.createdAt, since)));
+    const [held] = await tx.select({ n: sql`coalesce(sum(${appJobs.reservedCalls}), 0)::int` }).from(appJobs).where(and(
+      ne(appJobs.id, job.id),
+      sql`(${appJobs.status} in ('pending','running','cancelling') or ${appJobs.finishedAt} >= ${since})`
+    ));
+    const allowed = Number.isFinite(cap) ? Math.max(0, Math.floor(cap) - (spent?.n ?? 0) - (held?.n ?? 0)) : 0;
+    const reservedCalls = Math.min(current.reservedCalls, job.reservedCalls, allowed);
+    const [updated] = await tx.update(appJobs).set({ reservedCalls }).where(eq(appJobs.id, job.id)).returning();
+    return updated;
+  });
+}
+async function recordAppSpend(db, job, receipt) {
+  if (!receipt) return;
+  const sane = Number.isSafeInteger(receipt.calls) && receipt.calls >= 0 && receipt.calls <= MAX_APP_SPEND_CALLS;
+  if (!sane) throw new Error("invalid-app-spend-receipt");
+  await db.transaction(async (tx) => {
+    await tx.execute(sql`lock table ${appJobs} in share row exclusive mode`);
+    const current = await getAppJob(tx, job.id);
+    if (!current || current.reservedCalls === 0) return;
+    const count = Math.min(current.reservedCalls, receipt.calls);
+    for (let index = 0; index < count; index++) {
+      await tx.insert(modelCalls).values({
+        id: "app:" + job.id + ":" + index,
+        kind: "app",
+        appId: job.appId,
+        appJobId: job.id,
+        provider: receipt.provider ?? "unknown",
+        model: receipt.model ?? "unmetered",
+        identity: job.identity || null
+      }).onConflictDoNothing();
+    }
+    await tx.update(appJobs).set({ reservedCalls: 0 }).where(eq(appJobs.id, job.id));
+  });
+}
 
 // src/ingest.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import { readFile } from "fs/promises";
 import { basename, dirname, extname, join } from "path";
-import { and, eq, inArray, notInArray, or, sql } from "drizzle-orm";
+import { and as and2, eq as eq2, inArray as inArray2, notInArray, or, sql as sql2 } from "drizzle-orm";
 import {
   identityCandidate,
   slugify
@@ -53,7 +233,7 @@ var MIME_BY_EXTENSION = {
   ".ico": "image/x-icon"
 };
 function idFor(value) {
-  return createHash("sha1").update(value).digest("hex").slice(0, 24);
+  return createHash2("sha1").update(value).digest("hex").slice(0, 24);
 }
 var SNAPSHOTS_PER_PROJECT = 30;
 async function ingestPortfolio(db, analyses, families2 = [], scope, origins = []) {
@@ -137,44 +317,44 @@ async function writeCatalog(tx, { analyses, families: families2, scope, originBy
     }).onConflictDoUpdate({
       target: projects.id,
       set: {
-        name: sql`excluded.name`,
+        name: sql2`excluded.name`,
         // `slug` is not to be touched here: its owner is `assignSlugs`.
-        description: sql`excluded.description`,
-        version: sql`excluded.version`,
-        iconDataUri: sql`excluded.icon_data_uri`,
-        iconHash: sql`excluded.icon_hash`,
-        primaryLanguage: sql`excluded.primary_language`,
-        healthScore: sql`excluded.health_score`,
-        healthGrade: sql`excluded.health_grade`,
-        sourceBytes: sql`excluded.source_bytes`,
-        fileCount: sql`excluded.file_count`,
-        gitBranch: sql`excluded.git_branch`,
-        gitRemoteUrl: sql`excluded.git_remote_url`,
-        gitCommitCount: sql`excluded.git_commit_count`,
-        lastCommitAt: sql`excluded.last_commit_at`,
-        summary: sql`excluded.summary`,
-        summarySource: sql`excluded.summary_source`,
-        summaryReadme: sql`excluded.summary_readme`,
-        summaryComposed: sql`excluded.summary_composed`,
-        summaryComposition: sql`excluded.summary_composition`,
-        originKind: sql`excluded.origin_kind`,
-        originStartedBy: sql`excluded.origin_started_by`,
-        originShare: sql`excluded.origin_share`,
-        originEvidence: sql`excluded.origin_evidence`,
+        description: sql2`excluded.description`,
+        version: sql2`excluded.version`,
+        iconDataUri: sql2`excluded.icon_data_uri`,
+        iconHash: sql2`excluded.icon_hash`,
+        primaryLanguage: sql2`excluded.primary_language`,
+        healthScore: sql2`excluded.health_score`,
+        healthGrade: sql2`excluded.health_grade`,
+        sourceBytes: sql2`excluded.source_bytes`,
+        fileCount: sql2`excluded.file_count`,
+        gitBranch: sql2`excluded.git_branch`,
+        gitRemoteUrl: sql2`excluded.git_remote_url`,
+        gitCommitCount: sql2`excluded.git_commit_count`,
+        lastCommitAt: sql2`excluded.last_commit_at`,
+        summary: sql2`excluded.summary`,
+        summarySource: sql2`excluded.summary_source`,
+        summaryReadme: sql2`excluded.summary_readme`,
+        summaryComposed: sql2`excluded.summary_composed`,
+        summaryComposition: sql2`excluded.summary_composition`,
+        originKind: sql2`excluded.origin_kind`,
+        originStartedBy: sql2`excluded.origin_started_by`,
+        originShare: sql2`excluded.origin_share`,
+        originEvidence: sql2`excluded.origin_evidence`,
         // `ai_summary` **is not** to be touched: `panoma describe` writes it, it costs one call
         // to the model and a scan does not have to erase it.
-        runbook: sql`excluded.runbook`,
-        recentCommits: sql`excluded.recent_commits`,
-        agentsMd: sql`excluded.agents_md`,
-        gitVersioned: sql`excluded.git_versioned`,
-        gitModified: sql`excluded.git_modified`,
-        gitUntracked: sql`excluded.git_untracked`,
-        gitAhead: sql`excluded.git_ahead`,
-        gitBehind: sql`excluded.git_behind`,
-        gitStashes: sql`excluded.git_stashes`,
-        gitOwnRepo: sql`excluded.git_own_repo`,
-        depsUnresolved: sql`excluded.deps_unresolved`,
-        lastScannedAt: sql`excluded.last_scanned_at`
+        runbook: sql2`excluded.runbook`,
+        recentCommits: sql2`excluded.recent_commits`,
+        agentsMd: sql2`excluded.agents_md`,
+        gitVersioned: sql2`excluded.git_versioned`,
+        gitModified: sql2`excluded.git_modified`,
+        gitUntracked: sql2`excluded.git_untracked`,
+        gitAhead: sql2`excluded.git_ahead`,
+        gitBehind: sql2`excluded.git_behind`,
+        gitStashes: sql2`excluded.git_stashes`,
+        gitOwnRepo: sql2`excluded.git_own_repo`,
+        depsUnresolved: sql2`excluded.deps_unresolved`,
+        lastScannedAt: sql2`excluded.last_scanned_at`
         // `first_seen_at` stays as it was on purpose: it is the date when the project entered the
         // catalog, not the date of the last scan.
       }
@@ -194,7 +374,7 @@ async function writeCatalog(tx, { analyses, families: families2, scope, originBy
         await tx.insert(technologies).values({ id: tech.id, name: tech.name, kind: tech.kind, iconSlug: tech.iconSlug }).onConflictDoNothing();
       }
     }
-    await tx.delete(projectTechnologies).where(eq(projectTechnologies.projectId, projectId));
+    await tx.delete(projectTechnologies).where(eq2(projectTechnologies.projectId, projectId));
     if (analysis.technologies.length > 0) {
       await tx.insert(projectTechnologies).values(
         analysis.technologies.map((tech) => ({
@@ -223,7 +403,7 @@ async function writeCatalog(tx, { analyses, families: families2, scope, originBy
         }))
       ).onConflictDoNothing();
     }
-    await tx.delete(projectDependencies).where(eq(projectDependencies.projectId, projectId));
+    await tx.delete(projectDependencies).where(eq2(projectDependencies.projectId, projectId));
     if (dependencies.length > 0) {
       await tx.insert(projectDependencies).values(
         dedupeBy(dependencies, (d) => d.packageId).map((d) => ({
@@ -237,7 +417,7 @@ async function writeCatalog(tx, { analyses, families: families2, scope, originBy
         }))
       );
     }
-    await tx.delete(distributions).where(eq(distributions.projectId, projectId));
+    await tx.delete(distributions).where(eq2(distributions.projectId, projectId));
     if (analysis.distributions.length > 0) {
       await tx.insert(distributions).values(
         dedupeBy(analysis.distributions, (d) => `${d.kind}:${d.label}`).map((d) => ({
@@ -249,7 +429,7 @@ async function writeCatalog(tx, { analyses, families: families2, scope, originBy
         }))
       );
     }
-    await tx.delete(projectLinks).where(eq(projectLinks.projectId, projectId));
+    await tx.delete(projectLinks).where(eq2(projectLinks.projectId, projectId));
     if (analysis.links.length > 0) {
       await tx.insert(projectLinks).values(
         analysis.links.map((link) => ({
@@ -264,7 +444,7 @@ async function writeCatalog(tx, { analyses, families: families2, scope, originBy
         }))
       );
     }
-    await tx.delete(projectAgents).where(eq(projectAgents.projectId, projectId));
+    await tx.delete(projectAgents).where(eq2(projectAgents.projectId, projectId));
     const agents2 = analysis.git?.agentContributors ?? [];
     if (agents2.length > 0) {
       await tx.insert(projectAgents).values(
@@ -335,7 +515,7 @@ async function assignIdentities(tx, candidates) {
     const unique = candidate.value && claims.get(candidate.value).length === 1;
     const identity = unique ? candidate.value : `ruta:${idFor(root)}`;
     if (unique) stable++;
-    await tx.update(projects).set({ identity }).where(eq(projects.root, root));
+    await tx.update(projects).set({ identity }).where(eq2(projects.root, root));
   }
   return stable;
 }
@@ -346,7 +526,7 @@ async function assignSlugs(tx) {
     root: projects.root,
     slug: projects.slug,
     lastCommitAt: projects.lastCommitAt,
-    isCopy: sql`exists (
+    isCopy: sql2`exists (
         select 1 from family_members fm where fm.project_id = projects.id
       )`
   }).from(projects);
@@ -406,7 +586,7 @@ async function rename(tx, id, candidates) {
   for (const [index, slug] of candidates.entries()) {
     try {
       await tx.transaction(async (inner) => {
-        await inner.update(projects).set({ slug }).where(eq(projects.id, id));
+        await inner.update(projects).set({ slug }).where(eq2(projects.id, id));
       });
       return { first: index === 0 };
     } catch (error) {
@@ -442,7 +622,7 @@ async function readIcon(analysis) {
     if (buffer.byteLength > MAX_ICON_BYTES) return null;
     return {
       dataUri: `data:${mime};base64,${buffer.toString("base64")}`,
-      hash: createHash("sha1").update(buffer).digest("hex")
+      hash: createHash2("sha1").update(buffer).digest("hex")
     };
   } catch {
     return null;
@@ -456,39 +636,39 @@ async function deleteFamilies(tx, scope) {
   }
   const root = scope.replace(/\/+$/, "");
   const inside = or(
-    eq(projects.root, root),
-    sql`left(${projects.root}, ${codePoints(root) + 1}) = ${`${root}/`}`
+    eq2(projects.root, root),
+    sql2`left(${projects.root}, ${codePoints(root) + 1}) = ${`${root}/`}`
   );
-  const outside = await tx.select({ id: projects.id }).from(projects).where(sql`not (${inside})`);
+  const outside = await tx.select({ id: projects.id }).from(projects).where(sql2`not (${inside})`);
   const outsideIds = outside.map((row) => row.id);
   const untouchable = /* @__PURE__ */ new Set();
   if (outsideIds.length > 0) {
-    for (const row of await tx.select({ id: families.id }).from(families).where(inArray(families.canonicalProjectId, outsideIds))) {
+    for (const row of await tx.select({ id: families.id }).from(families).where(inArray2(families.canonicalProjectId, outsideIds))) {
       untouchable.add(row.id);
     }
-    for (const row of await tx.select({ familyId: familyMembers.familyId }).from(familyMembers).where(inArray(familyMembers.projectId, outsideIds))) {
+    for (const row of await tx.select({ familyId: familyMembers.familyId }).from(familyMembers).where(inArray2(familyMembers.projectId, outsideIds))) {
       untouchable.add(row.familyId);
     }
   }
   const allOf = await tx.select({ id: families.id }).from(families);
   const toDelete = allOf.map((f) => f.id).filter((id) => !untouchable.has(id));
   if (toDelete.length === 0) return;
-  await tx.delete(familyMembers).where(inArray(familyMembers.familyId, toDelete));
-  await tx.delete(families).where(inArray(families.id, toDelete));
+  await tx.delete(familyMembers).where(inArray2(familyMembers.familyId, toDelete));
+  await tx.delete(families).where(inArray2(families.id, toDelete));
 }
 async function pruneMissing(tx, scope, keep, candidates = /* @__PURE__ */ new Map()) {
   if (keep.length === 0) return 0;
   const root = scope.replace(/\/+$/, "");
   const stale = await tx.select({ id: projects.id, identity: projects.identity }).from(projects).where(
-    and(
+    and2(
       or(
-        eq(projects.root, root),
+        eq2(projects.root, root),
         // `left(root, n) = prefijo` and not `like`, because `_` and `%` are LIKE wildcards and on
         // this disk `~/Desktop/convertir_a_geojson` and `~/Desktop/convertir a geojson` coexist:
         // scanning the first one would make the pattern `.../convertir_a_geojson/%` match the
         // second, and the cleanup would take away projects that did exist. Fourteen folders on
         // the Desktop have an underscore. A prefix comparison interprets nothing.
-        sql`left(${projects.root}, ${codePoints(root) + 1}) = ${`${root}/`}`
+        sql2`left(${projects.root}, ${codePoints(root) + 1}) = ${`${root}/`}`
       ),
       notInArray(projects.id, keep)
     )
@@ -501,7 +681,7 @@ async function pruneMissing(tx, scope, keep, candidates = /* @__PURE__ */ new Ma
   }
   await rehomeMemory(tx, stale, candidates);
   await tx.delete(projects).where(
-    inArray(
+    inArray2(
       projects.id,
       stale.map((row) => row.id)
     )
@@ -517,8 +697,8 @@ async function rehomeMemory(tx, stale, candidates) {
     claims.set(value, [...claims.get(value) ?? [], projectId]);
   }
   const elsewhere = await tx.select({ id: projects.id, identity: projects.identity }).from(projects).where(
-    and(
-      inArray(
+    and2(
+      inArray2(
         projects.identity,
         movable.map((row) => row.identity)
       ),
@@ -531,19 +711,19 @@ async function rehomeMemory(tx, stale, candidates) {
     const heirs = [.../* @__PURE__ */ new Set([...scanned, ...stored])];
     if (heirs.length !== 1) continue;
     const heir = heirs[0];
-    await tx.update(notes).set({ projectId: heir }).where(eq(notes.projectId, row.id));
-    await tx.update(agentSessions).set({ projectId: heir }).where(eq(agentSessions.projectId, row.id));
-    await tx.update(agentActivities).set({ projectId: heir }).where(eq(agentActivities.projectId, row.id));
-    await tx.update(tasks).set({ projectId: heir }).where(eq(tasks.projectId, row.id));
-    await tx.update(consultations).set({ projectId: heir }).where(eq(consultations.projectId, row.id));
-    await tx.update(servings).set({ projectId: heir }).where(eq(servings.projectId, row.id));
-    await tx.update(launches).set({ projectId: heir }).where(eq(launches.projectId, row.id));
-    await tx.update(runs).set({ projectId: heir }).where(eq(runs.projectId, row.id));
+    await tx.update(notes).set({ projectId: heir }).where(eq2(notes.projectId, row.id));
+    await tx.update(agentSessions).set({ projectId: heir }).where(eq2(agentSessions.projectId, row.id));
+    await tx.update(agentActivities).set({ projectId: heir }).where(eq2(agentActivities.projectId, row.id));
+    await tx.update(tasks).set({ projectId: heir }).where(eq2(tasks.projectId, row.id));
+    await tx.update(consultations).set({ projectId: heir }).where(eq2(consultations.projectId, row.id));
+    await tx.update(servings).set({ projectId: heir }).where(eq2(servings.projectId, row.id));
+    await tx.update(launches).set({ projectId: heir }).where(eq2(launches.projectId, row.id));
+    await tx.update(runs).set({ projectId: heir }).where(eq2(runs.projectId, row.id));
   }
 }
 async function pruneSnapshots(tx, keep = SNAPSHOTS_PER_PROJECT) {
   const pruned = await tx.delete(snapshots).where(
-    sql`${snapshots.id} in (
+    sql2`${snapshots.id} in (
         select id from (
           select id,
                  row_number() over (
@@ -572,8 +752,8 @@ function queueWrite(work) {
 }
 
 // src/queries.ts
-import { randomUUID } from "crypto";
-import { and as and2, asc, desc, eq as eq2, gte, inArray as inArray2, isNotNull, isNull, or as or2, sql as sql2 } from "drizzle-orm";
+import { randomUUID as randomUUID2 } from "crypto";
+import { and as and3, asc as asc2, desc as desc2, eq as eq3, gte as gte2, inArray as inArray3, isNotNull, isNull, lt, or as or2, sql as sql3 } from "drizzle-orm";
 import { alias } from "drizzle-orm/pg-core";
 var DORMANT_DAYS = 365;
 var IDLE_DAYS = 60;
@@ -587,6 +767,7 @@ function stateOf(lastCommitAt) {
 async function listProjects(db) {
   const rows = await db.select({
     id: projects.id,
+    identity: projects.identity,
     name: projects.name,
     slug: projects.slug,
     root: projects.root,
@@ -595,7 +776,7 @@ async function listProjects(db) {
     summarySource: projects.summarySource,
     originKind: projects.originKind,
     originStartedBy: projects.originStartedBy,
-    hasIcon: sql2`(projects.icon_data_uri is not null)`,
+    hasIcon: sql3`(projects.icon_data_uri is not null)`,
     primaryLanguage: projects.primaryLanguage,
     healthScore: projects.healthScore,
     healthGrade: projects.healthGrade,
@@ -619,7 +800,7 @@ async function listProjects(db) {
     // qualify columns with their table, so interpolating `${t.projects.id}` in a correlated
     // subquery produces a plain `id` that collides with the `id` of the joined table ("column
     // reference is ambiguous").
-    technologies: sql2`coalesce((
+    technologies: sql3`coalesce((
         select json_agg(json_build_object(
           'id', tech.id, 'name', tech.name, 'kind', tech.kind, 'version', pt.version
         ) order by pt.confidence desc, tech.name)
@@ -627,18 +808,18 @@ async function listProjects(db) {
         join technologies tech on tech.id = pt.technology_id
         where pt.project_id = projects.id
       ), '[]'::json)`,
-    agents: sql2`coalesce((
+    agents: sql3`coalesce((
         select json_agg(json_build_object('name', pa.agent_name, 'commits', pa.commits)
           order by pa.commits desc)
         from project_agents pa
         where pa.project_id = projects.id
       ), '[]'::json)`,
-    copyCount: sql2`coalesce((
+    copyCount: sql3`coalesce((
         select count(*)::int from family_members fm
         join families f on f.id = fm.family_id
         where f.canonical_project_id = projects.id
       ), 0)`,
-    copyOf: sql2`(
+    copyOf: sql3`(
         select canon.name from family_members fm
         join families f on f.id = fm.family_id
         join projects canon on canon.id = f.canonical_project_id
@@ -648,14 +829,14 @@ async function listProjects(db) {
     // A finished proposal is the only thing in the catalog that **awaits a human decision**: the
     // agent did its part overnight and cannot continue without you. That is why it travels on the
     // card and not just on its page, and that is why it matters in 'attention'.
-    proposedRuns: sql2`coalesce((
+    proposedRuns: sql3`coalesce((
         select count(*)::int from runs
         where runs.project_id = projects.id and runs.status = 'propuesto'
       ), 0)`,
     // The first element of `recent_commits` is the most recent: the engine already keeps them
     // sorted, so there is no need to sort anything here.
-    lastCommitSubject: sql2`(projects.recent_commits->0->>'subject')`
-  }).from(projects).where(sql2`(select d.hidden from decisions d where d.identity = projects.identity) is not true`).orderBy(sql2`${projects.lastCommitAt} desc nulls last`, desc(projects.healthScore));
+    lastCommitSubject: sql3`(projects.recent_commits->0->>'subject')`
+  }).from(projects).where(sql3`(select d.hidden from decisions d where d.identity = projects.identity) is not true`).orderBy(sql3`${projects.lastCommitAt} desc nulls last`, desc2(projects.healthScore));
   return rows.map((row) => ({ ...row, work: workStateOf(row) }));
 }
 function workStateOf(row) {
@@ -670,9 +851,9 @@ function workStateOf(row) {
   };
 }
 async function getProject(db, slug) {
-  const [project] = await db.select().from(projects).where(eq2(projects.slug, slug)).limit(1);
+  const [project] = await db.select().from(projects).where(eq3(projects.slug, slug)).limit(1);
   if (!project) return void 0;
-  const [decision] = project.identity ? await db.select().from(decisions).where(eq2(decisions.identity, project.identity)).limit(1) : [];
+  const [decision] = project.identity ? await db.select().from(decisions).where(eq3(decisions.identity, project.identity)).limit(1) : [];
   const [technologies2, dependencies, dists, links, agents2, advisories2, history] = await Promise.all([
     db.select({
       id: technologies.id,
@@ -682,7 +863,7 @@ async function getProject(db, slug) {
       version: projectTechnologies.version,
       confidence: projectTechnologies.confidence,
       evidence: projectTechnologies.evidence
-    }).from(projectTechnologies).innerJoin(technologies, eq2(technologies.id, projectTechnologies.technologyId)).where(eq2(projectTechnologies.projectId, project.id)).orderBy(desc(projectTechnologies.confidence)),
+    }).from(projectTechnologies).innerJoin(technologies, eq3(technologies.id, projectTechnologies.technologyId)).where(eq3(projectTechnologies.projectId, project.id)).orderBy(desc2(projectTechnologies.confidence)),
     db.select({
       ecosystem: packages.ecosystem,
       name: packages.name,
@@ -692,11 +873,11 @@ async function getProject(db, slug) {
       isDev: projectDependencies.isDev,
       isDirect: projectDependencies.isDirect,
       source: projectDependencies.source
-    }).from(projectDependencies).innerJoin(packages, eq2(packages.id, projectDependencies.packageId)).where(eq2(projectDependencies.projectId, project.id)).orderBy(packages.ecosystem, packages.name),
-    db.select().from(distributions).where(eq2(distributions.projectId, project.id)),
+    }).from(projectDependencies).innerJoin(packages, eq3(packages.id, projectDependencies.packageId)).where(eq3(projectDependencies.projectId, project.id)).orderBy(packages.ecosystem, packages.name),
+    db.select().from(distributions).where(eq3(distributions.projectId, project.id)),
     // `deep` before `console`: those who really save time go first.
-    db.select().from(projectLinks).where(eq2(projectLinks.projectId, project.id)).orderBy(projectLinks.kind, projectLinks.service),
-    db.select().from(projectAgents).where(eq2(projectAgents.projectId, project.id)).orderBy(desc(projectAgents.commits)),
+    db.select().from(projectLinks).where(eq3(projectLinks.projectId, project.id)).orderBy(projectLinks.kind, projectLinks.service),
+    db.select().from(projectAgents).where(eq3(projectAgents.projectId, project.id)).orderBy(desc2(projectAgents.commits)),
     db.select({
       advisoryId: advisories.id,
       summary: advisories.summary,
@@ -706,18 +887,18 @@ async function getProject(db, slug) {
       packageName: packages.name,
       ecosystem: packages.ecosystem,
       affectedVersion: vulnerabilities.version
-    }).from(projectDependencies).innerJoin(packages, eq2(packages.id, projectDependencies.packageId)).innerJoin(
+    }).from(projectDependencies).innerJoin(packages, eq3(packages.id, projectDependencies.packageId)).innerJoin(
       vulnerabilities,
-      and2(
-        eq2(vulnerabilities.packageId, projectDependencies.packageId),
-        eq2(vulnerabilities.version, projectDependencies.resolvedVersion)
+      and3(
+        eq3(vulnerabilities.packageId, projectDependencies.packageId),
+        eq3(vulnerabilities.version, projectDependencies.resolvedVersion)
       )
-    ).innerJoin(advisories, eq2(advisories.id, vulnerabilities.advisoryId)).where(eq2(projectDependencies.projectId, project.id)),
+    ).innerJoin(advisories, eq3(advisories.id, vulnerabilities.advisoryId)).where(eq3(projectDependencies.projectId, project.id)),
     db.select({
       scannedAt: snapshots.scannedAt,
       healthScore: snapshots.healthScore,
       engineVersion: snapshots.engineVersion
-    }).from(snapshots).where(eq2(snapshots.projectId, project.id)).orderBy(desc(snapshots.scannedAt)).limit(30)
+    }).from(snapshots).where(eq3(snapshots.projectId, project.id)).orderBy(desc2(snapshots.scannedAt)).limit(30)
   ]);
   return {
     project,
@@ -744,7 +925,7 @@ async function listUnsavedWork(db) {
     name: projects.name,
     slug: projects.slug,
     root: projects.root,
-    hasIcon: sql2`(projects.icon_data_uri is not null)`,
+    hasIcon: sql3`(projects.icon_data_uri is not null)`,
     gitBranch: projects.gitBranch,
     gitRemoteUrl: projects.gitRemoteUrl,
     gitCommitCount: projects.gitCommitCount,
@@ -757,7 +938,7 @@ async function listUnsavedWork(db) {
     gitBehind: projects.gitBehind,
     gitStashes: projects.gitStashes,
     gitOwnRepo: projects.gitOwnRepo,
-    copyOf: sql2`(
+    copyOf: sql3`(
         select canon.name from family_members fm
         join families f on f.id = fm.family_id
         join projects canon on canon.id = f.canonical_project_id
@@ -765,38 +946,38 @@ async function listUnsavedWork(db) {
         limit 1
       )`
   }).from(projects).where(
-    and2(
+    and3(
       // Git was checked: `--no-git` sets this to null, and no conclusion can be drawn from that.
-      sql2`${projects.gitVersioned} is not null`,
+      sql3`${projects.gitVersioned} is not null`,
       or2(
         // There isn't even a repository. It's the biggest risk in the catalog and it was left out
         // precisely for that reason: the previous filter required data from the work tree, which
         // don't exist here because there is nothing to compare them with.
-        sql2`${projects.gitVersioned} = false`,
+        sql3`${projects.gitVersioned} = false`,
         // `git init` and nothing more. `git_commit_count` comes up null because `rev-list HEAD`
         // fails without HEAD; a folder with 497 files and zero commits came out as 'medium risk'
         // behind a single affected file.
-        sql2`(${projects.gitVersioned} and coalesce(${projects.gitCommitCount}, 0) = 0)`,
-        sql2`${projects.gitModified} > 0`,
+        sql3`(${projects.gitVersioned} and coalesce(${projects.gitCommitCount}, 0) = 0)`,
+        sql3`${projects.gitModified} > 0`,
         // Files that git does not know about and that are not ignored: they are not compilation
         // leftovers —those do not appear in `status` —, it is work outside of any history.
-        sql2`${projects.gitUntracked} > 0`,
-        sql2`${projects.gitAhead} > 0`,
-        sql2`${projects.gitStashes} > 0`,
-        sql2`(${projects.gitOwnRepo}
+        sql3`${projects.gitUntracked} > 0`,
+        sql3`${projects.gitAhead} > 0`,
+        sql3`${projects.gitStashes} > 0`,
+        sql3`(${projects.gitOwnRepo}
                and ${projects.gitRemoteUrl} is null
                and ${projects.gitCommitCount} > 0)`
       )
     )
   ).orderBy(
-    sql2`(case
+    sql3`(case
             when ${projects.gitVersioned} = false then 0
             when coalesce(${projects.gitCommitCount}, 0) = 0 then 1
             when ${projects.gitOwnRepo} and ${projects.gitRemoteUrl} is null then 2
             else 3 end)`,
-    sql2`coalesce(${projects.gitCommitCount}, 0) desc`,
-    sql2`coalesce(${projects.gitAhead}, 0) desc`,
-    sql2`coalesce(${projects.gitModified}, 0) + coalesce(${projects.gitUntracked}, 0) desc`
+    sql3`coalesce(${projects.gitCommitCount}, 0) desc`,
+    sql3`coalesce(${projects.gitAhead}, 0) desc`,
+    sql3`coalesce(${projects.gitModified}, 0) + coalesce(${projects.gitUntracked}, 0) desc`
   );
   return rows.map((row) => ({ ...row, work: workStateOf(row) }));
 }
@@ -806,32 +987,32 @@ async function listDiskUsage(db) {
     name: projects.name,
     slug: projects.slug,
     root: projects.root,
-    hasIcon: sql2`(projects.icon_data_uri is not null)`,
+    hasIcon: sql3`(projects.icon_data_uri is not null)`,
     lastCommitAt: projects.lastCommitAt,
     totalBytes: projects.diskTotalBytes,
     reclaimableBytes: projects.diskReclaimableBytes,
     dirs: projects.diskDirs,
     measuredAt: projects.diskMeasuredAt,
-    copyOf: sql2`(
+    copyOf: sql3`(
         select canon.name from family_members fm
         join families f on f.id = fm.family_id
         join projects canon on canon.id = f.canonical_project_id
         where fm.project_id = projects.id
         limit 1
       )`
-  }).from(projects).where(sql2`${projects.diskMeasuredAt} is not null`).orderBy(sql2`coalesce(${projects.diskReclaimableBytes}, 0) desc`);
+  }).from(projects).where(sql3`${projects.diskMeasuredAt} is not null`).orderBy(sql3`coalesce(${projects.diskReclaimableBytes}, 0) desc`);
   return rows.map((row) => ({ ...row, dirs: row.dirs ?? [] }));
 }
 async function getDiskTotals(db) {
   const [row] = await db.select({
-    measured: sql2`count(*)::int`,
-    totalBytes: sql2`coalesce(sum(disk_total_bytes), 0)::bigint`,
-    reclaimableBytes: sql2`coalesce(sum(disk_reclaimable_bytes), 0)::bigint`,
-    dormantReclaimableBytes: sql2`coalesce(sum(disk_reclaimable_bytes) filter (
-        where last_commit_at < now() - interval '${sql2.raw(String(DORMANT_DAYS))} days'
+    measured: sql3`count(*)::int`,
+    totalBytes: sql3`coalesce(sum(disk_total_bytes), 0)::bigint`,
+    reclaimableBytes: sql3`coalesce(sum(disk_reclaimable_bytes), 0)::bigint`,
+    dormantReclaimableBytes: sql3`coalesce(sum(disk_reclaimable_bytes) filter (
+        where last_commit_at < now() - interval '${sql3.raw(String(DORMANT_DAYS))} days'
            or last_commit_at is null), 0)::bigint`,
-    measuredAt: sql2`max(disk_measured_at)`
-  }).from(projects).where(sql2`${projects.diskMeasuredAt} is not null`);
+    measuredAt: sql3`max(disk_measured_at)`
+  }).from(projects).where(sql3`${projects.diskMeasuredAt} is not null`);
   return {
     measured: Number(row?.measured ?? 0),
     totalBytes: Number(row?.totalBytes ?? 0),
@@ -841,7 +1022,7 @@ async function getDiskTotals(db) {
   };
 }
 async function setHidden(db, id, hidden) {
-  const [project] = await db.select({ identity: projects.identity, name: projects.name }).from(projects).where(eq2(projects.id, id)).limit(1);
+  const [project] = await db.select({ identity: projects.identity, name: projects.name }).from(projects).where(eq3(projects.id, id)).limit(1);
   if (!project?.identity) return;
   await db.insert(decisions).values({ identity: project.identity, hidden, lastName: project.name }).onConflictDoUpdate({
     target: decisions.identity,
@@ -849,7 +1030,7 @@ async function setHidden(db, id, hidden) {
   });
 }
 async function excludeProject(db, id, confirmation) {
-  const [project] = await db.select({ name: projects.name, root: projects.root }).from(projects).where(eq2(projects.id, id)).limit(1);
+  const [project] = await db.select({ name: projects.name, root: projects.root }).from(projects).where(eq3(projects.id, id)).limit(1);
   if (!project) return void 0;
   if (confirmation !== void 0 && confirmation.trim() !== project.name) {
     throw new Error(
@@ -857,20 +1038,20 @@ async function excludeProject(db, id, confirmation) {
     );
   }
   await db.insert(exclusions).values({ root: project.root, name: project.name }).onConflictDoNothing();
-  await db.delete(projects).where(eq2(projects.id, id));
+  await db.delete(projects).where(eq3(projects.id, id));
   return project;
 }
 async function forgetProjectsUnder(db, root) {
   const scope = root.replace(/\/+$/, "");
   const doomed = await db.select({ id: projects.id }).from(projects).where(
     or2(
-      eq2(projects.root, scope),
-      sql2`left(${projects.root}, ${scope.length + 1}) = ${`${scope}/`}`
+      eq3(projects.root, scope),
+      sql3`left(${projects.root}, ${scope.length + 1}) = ${`${scope}/`}`
     )
   );
   if (doomed.length === 0) return 0;
   await db.delete(projects).where(
-    inArray2(
+    inArray3(
       projects.id,
       doomed.map((row) => row.id)
     )
@@ -878,7 +1059,7 @@ async function forgetProjectsUnder(db, root) {
   return doomed.length;
 }
 async function unexcludeProject(db, root) {
-  await db.delete(exclusions).where(eq2(exclusions.root, root));
+  await db.delete(exclusions).where(eq3(exclusions.root, root));
 }
 async function listHidden(db) {
   const [hidden, excluded] = await Promise.all([
@@ -887,9 +1068,9 @@ async function listHidden(db) {
       name: projects.name,
       slug: projects.slug,
       root: projects.root,
-      hasIcon: sql2`(projects.icon_data_uri is not null)`
-    }).from(projects).where(sql2`(select d.hidden from decisions d where d.identity = projects.identity) is true`).orderBy(projects.name),
-    db.select().from(exclusions).orderBy(desc(exclusions.excludedAt))
+      hasIcon: sql3`(projects.icon_data_uri is not null)`
+    }).from(projects).where(sql3`(select d.hidden from decisions d where d.identity = projects.identity) is true`).orderBy(projects.name),
+    db.select().from(exclusions).orderBy(desc2(exclusions.excludedAt))
   ]);
   return { hidden, excluded };
 }
@@ -914,26 +1095,27 @@ async function saveDiskUsage(db, id, report) {
     diskReclaimableBytes: report.reclaimableBytes,
     diskDirs: report.dirs,
     diskMeasuredAt: /* @__PURE__ */ new Date()
-  }).where(eq2(projects.id, id));
+  }).where(eq3(projects.id, id));
 }
 async function getProjectLocation(db, id) {
-  const [row] = await db.select({ root: projects.root, name: projects.name }).from(projects).where(eq2(projects.id, id)).limit(1);
+  const [row] = await db.select({ root: projects.root, name: projects.name }).from(projects).where(eq3(projects.id, id)).limit(1);
   return row;
 }
-async function saveAiSummary(db, id, text, model, lang) {
-  const [project] = await db.select({ identity: projects.identity, name: projects.name }).from(projects).where(eq2(projects.id, id)).limit(1);
+async function saveAiSummary(db, id, text, model, lang, hash) {
+  const [project] = await db.select({ identity: projects.identity, name: projects.name }).from(projects).where(eq3(projects.id, id)).limit(1);
   if (!project?.identity) return;
   const value = {
     aiSummary: text,
     aiSummaryModel: model,
     aiSummaryAt: /* @__PURE__ */ new Date(),
     aiSummaryLang: lang,
+    aiSummaryHash: hash,
     lastName: project.name
   };
   await db.insert(decisions).values({ identity: project.identity, ...value }).onConflictDoUpdate({ target: decisions.identity, set: { ...value, updatedAt: /* @__PURE__ */ new Date() } });
 }
 async function saveMdReview(db, id, text, model, hash, lang) {
-  const [project] = await db.select({ identity: projects.identity, name: projects.name }).from(projects).where(eq2(projects.id, id)).limit(1);
+  const [project] = await db.select({ identity: projects.identity, name: projects.name }).from(projects).where(eq3(projects.id, id)).limit(1);
   if (!project?.identity) return;
   const value = {
     mdReview: text,
@@ -946,29 +1128,29 @@ async function saveMdReview(db, id, text, model, hash, lang) {
   await db.insert(decisions).values({ identity: project.identity, ...value }).onConflictDoUpdate({ target: decisions.identity, set: { ...value, updatedAt: /* @__PURE__ */ new Date() } });
 }
 async function saveProjectAccounts(db, id, accounts) {
-  const [project] = await db.select({ identity: projects.identity, name: projects.name }).from(projects).where(eq2(projects.id, id)).limit(1);
+  const [project] = await db.select({ identity: projects.identity, name: projects.name }).from(projects).where(eq3(projects.id, id)).limit(1);
   if (!project?.identity) return;
   const value = { accounts, lastName: project.name };
   await db.insert(decisions).values({ identity: project.identity, ...value }).onConflictDoUpdate({ target: decisions.identity, set: { ...value, updatedAt: /* @__PURE__ */ new Date() } });
 }
 async function saveBuildCheck(db, id, verdict) {
-  const [project] = await db.select({ identity: projects.identity, name: projects.name }).from(projects).where(eq2(projects.id, id)).limit(1);
+  const [project] = await db.select({ identity: projects.identity, name: projects.name }).from(projects).where(eq3(projects.id, id)).limit(1);
   if (!project?.identity) return;
   const value = { buildCheck: verdict, lastName: project.name };
   await db.insert(decisions).values({ identity: project.identity, ...value }).onConflictDoUpdate({ target: decisions.identity, set: { ...value, updatedAt: /* @__PURE__ */ new Date() } });
 }
 async function saveNorth(db, slug, north) {
-  const [project] = await db.select({ identity: projects.identity, name: projects.name }).from(projects).where(eq2(projects.slug, slug)).limit(1);
+  const [project] = await db.select({ identity: projects.identity, name: projects.name }).from(projects).where(eq3(projects.slug, slug)).limit(1);
   if (!project?.identity) return;
   const value = { north, lastName: project.name };
   await db.insert(decisions).values({ identity: project.identity, ...value }).onConflictDoUpdate({ target: decisions.identity, set: { ...value, updatedAt: /* @__PURE__ */ new Date() } });
 }
 async function getNorth(db, identity) {
-  const [row] = await db.select({ north: decisions.north }).from(decisions).where(eq2(decisions.identity, identity)).limit(1);
+  const [row] = await db.select({ north: decisions.north }).from(decisions).where(eq3(decisions.identity, identity)).limit(1);
   return row?.north ?? void 0;
 }
 async function getProjectIcon(db, id) {
-  const [row] = await db.select({ icon: projects.iconDataUri, hash: projects.iconHash }).from(projects).where(eq2(projects.id, id)).limit(1);
+  const [row] = await db.select({ icon: projects.iconDataUri, hash: projects.iconHash }).from(projects).where(eq3(projects.id, id)).limit(1);
   const match = row?.icon ? /^data:([^;]+);base64,(.+)$/.exec(row.icon) : null;
   if (!match) return void 0;
   const buffer = Buffer.from(match[2], "base64");
@@ -991,7 +1173,7 @@ async function listFamilies(db) {
       slug: canon.slug,
       lastCommitAt: canon.lastCommitAt
     },
-    copies: sql2`coalesce((
+    copies: sql3`coalesce((
         select json_agg(json_build_object(
           'name', p.name, 'root', p.root, 'slug', p.slug,
           'confidence', fm.confidence, 'reason', fm.reason, 'daysBehind', fm.days_behind
@@ -1000,10 +1182,10 @@ async function listFamilies(db) {
         join projects p on p.id = fm.project_id
         where fm.family_id = families.id
       ), '[]'::json)`
-  }).from(families).innerJoin(canon, eq2(canon.id, families.canonicalProjectId)).orderBy(desc(families.redundantBytes));
+  }).from(families).innerJoin(canon, eq3(canon.id, families.canonicalProjectId)).orderBy(desc2(families.redundantBytes));
   return rows;
 }
-var notACopy = sql2`not exists (
+var notACopy = sql3`not exists (
   select 1 from family_members fm where fm.project_id = projects.id
 ) and (select d.hidden from decisions d where d.identity = projects.identity) is not true`;
 async function getStats(db) {
@@ -1012,7 +1194,7 @@ async function getStats(db) {
     // copies, twelve folders of the same app counted as twelve live projects, and the sidebar
     // said fourteen active while there were three on screen. A number that cannot be pointed out
     // in the interface is a number that lies.
-    projects: sql2`(select count(*)::int from ${projects} where ${notACopy})`,
+    projects: sql3`(select count(*)::int from ${projects} where ${notACopy})`,
     /*
       The four states of `stateOf`, and the four add up to `projects`.
       Before there were two and they didn't match: `dormant` grouped the sleeping ones with
@@ -1025,55 +1207,55 @@ async function getStats(db) {
       and the grid cannot disagree again: without a date it is `no-git`, more than a year
       `dormant`, more than two months `paused`, and the rest `active`.
      */
-    live: sql2`(select count(*)::int from ${projects}
+    live: sql3`(select count(*)::int from ${projects}
         where ${notACopy}
-          and last_commit_at > now() - interval '${sql2.raw(String(IDLE_DAYS))} days')`,
-    paused: sql2`(select count(*)::int from ${projects}
+          and last_commit_at > now() - interval '${sql3.raw(String(IDLE_DAYS))} days')`,
+    paused: sql3`(select count(*)::int from ${projects}
         where ${notACopy}
-          and last_commit_at <= now() - interval '${sql2.raw(String(IDLE_DAYS))} days'
-          and last_commit_at >= now() - interval '${sql2.raw(String(DORMANT_DAYS))} days')`,
-    dormant: sql2`(select count(*)::int from ${projects}
+          and last_commit_at <= now() - interval '${sql3.raw(String(IDLE_DAYS))} days'
+          and last_commit_at >= now() - interval '${sql3.raw(String(DORMANT_DAYS))} days')`,
+    dormant: sql3`(select count(*)::int from ${projects}
         where ${notACopy}
-          and last_commit_at < now() - interval '${sql2.raw(String(DORMANT_DAYS))} days')`,
-    noGit: sql2`(select count(*)::int from ${projects}
+          and last_commit_at < now() - interval '${sql3.raw(String(DORMANT_DAYS))} days')`,
+    noGit: sql3`(select count(*)::int from ${projects}
         where ${notACopy} and last_commit_at is null)`,
-    copies: sql2`(select count(*)::int from ${familyMembers})`,
+    copies: sql3`(select count(*)::int from ${familyMembers})`,
     /*
       Counted from the decision and not from the project: `notACopy` reads `decisions.hidden`
       through `identity`, which is what survives moving the folder, and a decision can outlive
       the row it was about. Only rows that are still in the catalog are counted, so the figure
       can always be pointed at — and one that is also a copy is not counted twice.
      */
-    hidden: sql2`(select count(*)::int from ${projects} p
+    hidden: sql3`(select count(*)::int from ${projects} p
         where not exists (select 1 from family_members fm where fm.project_id = p.id)
           and (select d.hidden from decisions d where d.identity = p.identity) is true)`,
-    redundantBytes: sql2`(select coalesce(sum(redundant_bytes), 0)::int from ${families})`,
-    agentCommits: sql2`(select coalesce(sum(commits), 0)::int from ${projectAgents})`,
-    technologies: sql2`(select count(*)::int from ${technologies})`,
-    packages: sql2`(select count(*)::int from ${packages})`,
-    outdatedDeps: sql2`(select coalesce(sum(outdated_deps), 0)::int from ${projects})`,
-    vulnerableProjects: sql2`(select count(*)::int from ${projects} where vuln_count > 0)`,
-    advisories: sql2`(select count(*)::int from ${advisories})`,
-    enrichedAt: sql2`(select max(enriched_at) from ${projects})`,
+    redundantBytes: sql3`(select coalesce(sum(redundant_bytes), 0)::int from ${families})`,
+    agentCommits: sql3`(select coalesce(sum(commits), 0)::int from ${projectAgents})`,
+    technologies: sql3`(select count(*)::int from ${technologies})`,
+    packages: sql3`(select count(*)::int from ${packages})`,
+    outdatedDeps: sql3`(select coalesce(sum(outdated_deps), 0)::int from ${projects})`,
+    vulnerableProjects: sql3`(select count(*)::int from ${projects} where vuln_count > 0)`,
+    advisories: sql3`(select count(*)::int from ${advisories})`,
+    enrichedAt: sql3`(select max(enriched_at) from ${projects})`,
     // Unfiltered copies, just like `listUnsavedWork`: the counter has to match the list it opens,
     // and in a copy is where the work truly gets lost.
-    unsaved: sql2`(select count(*)::int from ${projects}
+    unsaved: sql3`(select count(*)::int from ${projects}
         where git_versioned is not null
           and (git_versioned = false
                or (git_versioned and coalesce(git_commit_count, 0) = 0)
                or git_modified > 0 or git_untracked > 0 or git_ahead > 0 or git_stashes > 0
                or (git_own_repo and git_remote_url is null and git_commit_count > 0)))`,
-    noRemote: sql2`(select count(*)::int from ${projects}
+    noRemote: sql3`(select count(*)::int from ${projects}
         where git_own_repo and git_remote_url is null and git_commit_count > 0)`,
     /** Folders with code and without a repository: nothing to undo, nothing to recover. */
-    unversioned: sql2`(select count(*)::int from ${projects}
+    unversioned: sql3`(select count(*)::int from ${projects}
         where git_versioned = false)`,
-    notMine: sql2`(select count(*)::int from ${projects}
+    notMine: sql3`(select count(*)::int from ${projects}
         where origin_kind in ('ajeno', 'bifurcado'))`,
     // Without filtering copies or hiding them: a finished proposal awaits a decision even if its
     // project does not appear on the grid, and hiding it would be losing work already done.
-    proposedRuns: sql2`(select count(*)::int from ${runs} where status = 'propuesto')`
-  }).from(sql2`(select 1) as _`);
+    proposedRuns: sql3`(select count(*)::int from ${runs} where status = 'propuesto')`
+  }).from(sql3`(select 1) as _`);
   return {
     ...row,
     enrichedAt: row?.enrichedAt ? new Date(row.enrichedAt) : null
@@ -1086,10 +1268,10 @@ async function listPackages(db) {
     name: packages.name,
     latestVersion: packages.latestVersion,
     deprecated: packages.deprecated,
-    projects: sql2`(
+    projects: sql3`(
         select count(*)::int from project_dependencies pd where pd.package_id = packages.id
       )`,
-    versionsInUse: sql2`coalesce((
+    versionsInUse: sql3`coalesce((
         select json_agg(v order by v.projects desc, v.version)
         from (
           select pd.resolved_version as version, count(*)::int as projects
@@ -1098,11 +1280,11 @@ async function listPackages(db) {
           group by pd.resolved_version
         ) v
       ), '[]'::json)`,
-    advisories: sql2`(
+    advisories: sql3`(
         select count(distinct vu.advisory_id)::int
         from vulnerabilities vu where vu.package_id = packages.id
       )`,
-    worstSeverity: sql2`(
+    worstSeverity: sql3`(
         select a.severity from vulnerabilities vu
         join advisories a on a.id = vu.advisory_id
         where vu.package_id = packages.id
@@ -1111,7 +1293,7 @@ async function listPackages(db) {
           when 'baja' then 3 else 4 end
         limit 1
       )`
-  }).from(packages).orderBy(sql2`(
+  }).from(packages).orderBy(sql3`(
       select count(*) from project_dependencies pd where pd.package_id = packages.id
     ) desc`, packages.name);
   return rows;
@@ -1119,8 +1301,8 @@ async function listPackages(db) {
 async function getDailyReport(db, since) {
   const now = /* @__PURE__ */ new Date();
   const window = since ?? new Date(now.getTime() - 24 * 60 * 60 * 1e3);
-  const iso = window.toISOString();
-  const [total] = await db.select({ n: sql2`count(*)::int` }).from(projects);
+  const iso2 = window.toISOString();
+  const [total] = await db.select({ n: sql3`count(*)::int` }).from(projects);
   const catalog = total?.n ?? 0;
   const projects2 = await db.select({
     id: projects.id,
@@ -1142,36 +1324,36 @@ async function getDailyReport(db, since) {
       report**. `nullif` protects against the commit without a date, which the engine leaves as
       an empty string and that a plain `::timestamptz` would crash with an error.
      */
-    commits: sql2`coalesce((
+    commits: sql3`coalesce((
         select json_agg(json_build_object(
           'sha', c->>'sha', 'at', c->>'at', 'subject', c->>'subject', 'agent', c->>'agent'
         ) order by nullif(c->>'at', '')::timestamptz desc)
         from jsonb_array_elements(projects.recent_commits) c
-        where nullif(c->>'at', '')::timestamptz > ${iso}::timestamptz
+        where nullif(c->>'at', '')::timestamptz > ${iso2}::timestamptz
       ), '[]'::json)`,
-    agents: sql2`coalesce((
+    agents: sql3`coalesce((
         select json_agg(json_build_object('name', ag.name, 'activities', n) order by n desc)
         from (
           select aa.agent_id, count(*)::int as n
           from agent_activities aa
-          where aa.project_id = projects.id and aa.created_at > ${iso}
+          where aa.project_id = projects.id and aa.created_at > ${iso2}
           group by aa.agent_id
         ) act
         join agents ag on ag.id = act.agent_id
       ), '[]'::json)`
   }).from(projects).where(
-    sql2`(select d.hidden from decisions d where d.identity = projects.identity) is not true
+    sql3`(select d.hidden from decisions d where d.identity = projects.identity) is not true
         and (
           exists (
             select 1 from jsonb_array_elements(projects.recent_commits) c
-            where nullif(c->>'at', '')::timestamptz > ${iso}::timestamptz
+            where nullif(c->>'at', '')::timestamptz > ${iso2}::timestamptz
           )
           or exists (
             select 1 from agent_activities aa
-            where aa.project_id = projects.id and aa.created_at > ${iso}
+            where aa.project_id = projects.id and aa.created_at > ${iso2}
           )
         )`
-  ).orderBy(sql2`${projects.lastCommitAt} desc nulls last`);
+  ).orderBy(sql3`${projects.lastCommitAt} desc nulls last`);
   const proposals = await db.select({
     id: runs.id,
     project: projects.name,
@@ -1179,26 +1361,26 @@ async function getDailyReport(db, since) {
     target: runs.target,
     verified: runs.verified,
     when: runs.createdAt
-  }).from(runs).innerJoin(projects, eq2(projects.id, runs.projectId)).where(eq2(runs.status, "proposed")).orderBy(desc(runs.createdAt));
-  const born = await db.select({ slug: projects.slug, name: projects.name, when: projects.firstSeenAt }).from(projects).where(sql2`projects.first_seen_at > ${iso}`).orderBy(desc(projects.firstSeenAt));
+  }).from(runs).innerJoin(projects, eq3(projects.id, runs.projectId)).where(eq3(runs.status, "proposed")).orderBy(desc2(runs.createdAt));
+  const born = await db.select({ slug: projects.slug, name: projects.name, when: projects.firstSeenAt }).from(projects).where(sql3`projects.first_seen_at > ${iso2}`).orderBy(desc2(projects.firstSeenAt));
   const [lookedAlone] = await db.select({
-    looks: sql2`count(*)::int`,
-    findings: sql2`coalesce(sum(jsonb_array_length(${looks.findings})), 0)::int`
-  }).from(looks).where(and2(eq2(looks.fired, "watch"), sql2`${looks.at} > ${iso}`));
+    looks: sql3`count(*)::int`,
+    findings: sql3`coalesce(sum(jsonb_array_length(${looks.findings})), 0)::int`
+  }).from(looks).where(and3(eq3(looks.fired, "watch"), sql3`${looks.at} > ${iso2}`));
   const [reviewed] = await db.select({
-    reviews: sql2`count(*)::int`,
-    findings: sql2`coalesce(sum(jsonb_array_length(${reviews.findings})), 0)::int`
-  }).from(reviews).where(sql2`${reviews.at} > ${iso}`);
+    reviews: sql3`count(*)::int`,
+    findings: sql3`coalesce(sum(jsonb_array_length(${reviews.findings})), 0)::int`
+  }).from(reviews).where(sql3`${reviews.at} > ${iso2}`);
   const mirados = await db.select({
     slug: projects.slug,
     name: projects.name,
-    findings: sql2`coalesce(sum(jsonb_array_length(${looks.findings})), 0)::int`
-  }).from(looks).innerJoin(projects, eq2(projects.identity, looks.identity)).where(and2(eq2(looks.fired, "watch"), sql2`${looks.at} > ${iso}`)).groupBy(projects.slug, projects.name);
+    findings: sql3`coalesce(sum(jsonb_array_length(${looks.findings})), 0)::int`
+  }).from(looks).innerJoin(projects, eq3(projects.identity, looks.identity)).where(and3(eq3(looks.fired, "watch"), sql3`${looks.at} > ${iso2}`)).groupBy(projects.slug, projects.name);
   const revisados = await db.select({
     slug: projects.slug,
     name: projects.name,
-    findings: sql2`coalesce(sum(jsonb_array_length(${reviews.findings})), 0)::int`
-  }).from(reviews).innerJoin(projects, eq2(projects.id, reviews.projectId)).where(sql2`${reviews.at} > ${iso}`).groupBy(projects.slug, projects.name);
+    findings: sql3`coalesce(sum(jsonb_array_length(${reviews.findings})), 0)::int`
+  }).from(reviews).innerJoin(projects, eq3(projects.id, reviews.projectId)).where(sql3`${reviews.at} > ${iso2}`).groupBy(projects.slug, projects.name);
   const porProyecto = /* @__PURE__ */ new Map();
   for (const fila of [...mirados, ...revisados]) {
     if (fila.findings === 0) continue;
@@ -1215,24 +1397,24 @@ async function getDailyReport(db, since) {
     // It asks about the paragraph of README and not about the file: a README of one line with the
     // project name exists on disk and tells nothing. It is the same criterion that `factsOf` uses
     // to decide whether to offer the task of making it presentable.
-    hasReadme: sql2`(${projects.summaryReadme} is not null)`,
+    hasReadme: sql3`(${projects.summaryReadme} is not null)`,
     health: projects.healthScore,
     outdated: projects.outdatedDeps,
     notices: projects.vulnCount,
     // The two states that an agent considers pending work, the same ones that `getAgentContext`
     // filters: if this account and that query were to disagree, the catalog would propose one
     // more task on a queue that the agent already sees as full.
-    openTasks: sql2`(
+    openTasks: sql3`(
         select count(*)::int from tasks
         where tasks.project_id = ${projects.id}
           and tasks.status in ('open', 'in-progress')
       )`,
     north: decisions.north,
-    built: sql2`(${decisions.buildCheck} is not null)`,
+    built: sql3`(${decisions.buildCheck} is not null)`,
     // What the critic saw at no cost. It is counted in the database and the list is not
     // brought: the director only needs to know if there is something, and the lists of twenty
     // folders are heavy.
-    critiques: sql2`coalesce((
+    critiques: sql3`coalesce((
         select jsonb_array_length(reviews.findings) from reviews
         where reviews.project_id = ${projects.id}
       ), 0)`,
@@ -1245,7 +1427,7 @@ async function getDailyReport(db, since) {
     gitBehind: projects.gitBehind,
     gitStashes: projects.gitStashes,
     gitOwnRepo: projects.gitOwnRepo
-  }).from(projects).leftJoin(decisions, eq2(decisions.identity, projects.identity)).where(sql2`${decisions.hidden} is not true`).orderBy(sql2`${projects.lastCommitAt} desc nulls last`);
+  }).from(projects).leftJoin(decisions, eq3(decisions.identity, projects.identity)).where(sql3`${decisions.hidden} is not true`).orderBy(sql3`${projects.lastCommitAt} desc nulls last`);
   const commits = projects2.reduce((sum, p) => sum + (p.commits?.length ?? 0), 0);
   const byAgents = projects2.reduce(
     (sum, p) => sum + (p.commits ?? []).filter((c) => c.agent).length,
@@ -1360,7 +1542,7 @@ async function saveVerdicts(db, rows) {
 async function remap(db, chunk, inserted) {
   const existing = chunk.filter((one) => !inserted.has(one.id));
   if (existing.length === 0) return 0;
-  const stored = await db.select({ id: verdicts.id, identity: verdicts.identity }).from(verdicts).where(inArray2(verdicts.id, existing.map((one) => one.id)));
+  const stored = await db.select({ id: verdicts.id, identity: verdicts.identity }).from(verdicts).where(inArray3(verdicts.id, existing.map((one) => one.id)));
   const now = new Map(stored.map((row) => [row.id, row.identity]));
   const byIdentity = /* @__PURE__ */ new Map();
   for (const one of existing) {
@@ -1371,13 +1553,13 @@ async function remap(db, chunk, inserted) {
   }
   let changed = 0;
   for (const [identity, ids] of byIdentity) {
-    await db.update(verdicts).set({ identity }).where(inArray2(verdicts.id, ids));
+    await db.update(verdicts).set({ identity }).where(inArray3(verdicts.id, ids));
     changed += ids.length;
   }
   return changed;
 }
 async function projectNamesByIdentity(db) {
-  const rows = await db.select({ identity: projects.identity, name: projects.name }).from(projects).where(sql2`${projects.identity} is not null`);
+  const rows = await db.select({ identity: projects.identity, name: projects.name }).from(projects).where(sql3`${projects.identity} is not null`);
   const names = {};
   for (const row of rows) {
     if (row.identity && names[row.identity] === void 0) names[row.identity] = row.name;
@@ -1387,23 +1569,23 @@ async function projectNamesByIdentity(db) {
 async function listVerdicts(db, options = {}) {
   const { identity, accepted } = options;
   const filters = [];
-  if (identity !== void 0) filters.push(eq2(verdicts.identity, identity));
+  if (identity !== void 0) filters.push(eq3(verdicts.identity, identity));
   if (accepted === null) filters.push(isNull(verdicts.accepted));
-  else if (accepted !== void 0) filters.push(eq2(verdicts.accepted, accepted));
-  const query = db.select().from(verdicts).where(filters.length > 0 ? and2(...filters) : void 0).orderBy(desc(verdicts.createdAt), desc(verdicts.at), asc(verdicts.id));
+  else if (accepted !== void 0) filters.push(eq3(verdicts.accepted, accepted));
+  const query = db.select().from(verdicts).where(filters.length > 0 ? and3(...filters) : void 0).orderBy(desc2(verdicts.createdAt), desc2(verdicts.at), asc2(verdicts.id));
   const rows = options.limit === void 0 ? await query : await query.limit(options.limit);
   return rows.map((row) => ({ ...row, signals: row.signals ?? [] }));
 }
 async function deleteVerdicts(db, filter = {}) {
   const filters = [];
-  if (filter.source !== void 0) filters.push(eq2(verdicts.source, filter.source));
-  if (filter.sessionId !== void 0) filters.push(eq2(verdicts.sessionId, filter.sessionId));
-  if (filter.identity !== void 0) filters.push(eq2(verdicts.identity, filter.identity));
-  const rows = await db.delete(verdicts).where(filters.length > 0 ? and2(...filters) : void 0).returning({ id: verdicts.id });
+  if (filter.source !== void 0) filters.push(eq3(verdicts.source, filter.source));
+  if (filter.sessionId !== void 0) filters.push(eq3(verdicts.sessionId, filter.sessionId));
+  if (filter.identity !== void 0) filters.push(eq3(verdicts.identity, filter.identity));
+  const rows = await db.delete(verdicts).where(filters.length > 0 ? and3(...filters) : void 0).returning({ id: verdicts.id });
   return rows.length;
 }
 async function saveDesignFingerprint(db, projectId, data) {
-  const [project] = await db.select({ id: projects.id }).from(projects).where(eq2(projects.id, projectId)).limit(1);
+  const [project] = await db.select({ id: projects.id }).from(projects).where(eq3(projects.id, projectId)).limit(1);
   if (!project) return;
   await db.insert(designFingerprints).values({ projectId, data }).onConflictDoUpdate({
     target: designFingerprints.projectId,
@@ -1411,12 +1593,12 @@ async function saveDesignFingerprint(db, projectId, data) {
   });
 }
 async function getDesignFingerprint(db, projectId) {
-  const [row] = await db.select({ data: designFingerprints.data }).from(designFingerprints).where(eq2(designFingerprints.projectId, projectId)).limit(1);
+  const [row] = await db.select({ data: designFingerprints.data }).from(designFingerprints).where(eq3(designFingerprints.projectId, projectId)).limit(1);
   return row === void 0 ? void 0 : row.data;
 }
 var DESIGN_SHOWN = { colors: 12, fonts: 8, radii: 8 };
 async function portfolioDesign(db) {
-  const rows = await db.select({ data: designFingerprints.data }).from(designFingerprints).innerJoin(projects, eq2(projects.id, designFingerprints.projectId)).where(notACopy);
+  const rows = await db.select({ data: designFingerprints.data }).from(designFingerprints).innerJoin(projects, eq3(projects.id, designFingerprints.projectId)).where(notACopy);
   const colors = /* @__PURE__ */ new Map();
   const fonts = /* @__PURE__ */ new Map();
   const radii = /* @__PURE__ */ new Map();
@@ -1507,7 +1689,7 @@ async function saveObservations(db, rows) {
   const known = await db.select({ identity: observations.identity, statement: observations.statement }).from(observations).where(
     or2(
       ...identities.map(
-        (identity) => identity === null ? isNull(observations.identity) : eq2(observations.identity, identity)
+        (identity) => identity === null ? isNull(observations.identity) : eq3(observations.identity, identity)
       )
     )
   );
@@ -1541,27 +1723,27 @@ function newestCitation(citations) {
 async function listObservations(db, options = {}) {
   const { topic, classified, identity } = options;
   const filters = [];
-  if (topic !== void 0) filters.push(eq2(observations.topic, topic));
-  if (classified !== void 0) filters.push(eq2(observations.classified, classified));
+  if (topic !== void 0) filters.push(eq3(observations.topic, topic));
+  if (classified !== void 0) filters.push(eq3(observations.classified, classified));
   if (identity === null) filters.push(isNull(observations.identity));
-  else if (identity !== void 0) filters.push(eq2(observations.identity, identity));
-  const query = db.select().from(observations).where(filters.length > 0 ? and2(...filters) : void 0).orderBy(desc(observations.at), asc(observations.id));
+  else if (identity !== void 0) filters.push(eq3(observations.identity, identity));
+  const query = db.select().from(observations).where(filters.length > 0 ? and3(...filters) : void 0).orderBy(desc2(observations.at), asc2(observations.id));
   const rows = options.limit === void 0 ? await query : await query.limit(options.limit);
   return rows.map((row) => ({ ...row, citations: row.citations ?? [] }));
 }
 async function observationTopics(db) {
   const rows = await db.select({
     topic: observations.topic,
-    observations: sql2`count(*)::int`,
-    unclassified: sql2`count(*) filter (where not classified)::int`,
+    observations: sql3`count(*)::int`,
+    unclassified: sql3`count(*) filter (where not classified)::int`,
     /*
       In seconds from the era and not as a date: what comes from a `max()` written by hand does
       not go through the column converter, so it arrives as the string that Postgres prints
       —"2026-08-22 04:47:11.604-05"— and `new Date` that depends on the engine. A number depends
       on no one. The date is composed here, in a single place, as in `listBeliefs`.
      */
-    newest: sql2`extract(epoch from max(topic_at))::double precision`
-  }).from(observations).groupBy(observations.topic).orderBy(desc(sql2`count(*)`), asc(observations.topic));
+    newest: sql3`extract(epoch from max(topic_at))::double precision`
+  }).from(observations).groupBy(observations.topic).orderBy(desc2(sql3`count(*)`), asc2(observations.topic));
   return rows.map((row) => ({
     ...row,
     newest: row.newest === null ? null : new Date(row.newest * 1e3)
@@ -1570,7 +1752,7 @@ async function observationTopics(db) {
 async function setObservationTopics(db, rows) {
   let changed = 0;
   for (const row of rows) {
-    const done = await db.update(observations).set({ topic: row.topic, classified: true, topicAt: /* @__PURE__ */ new Date() }).where(eq2(observations.id, row.id)).returning({ id: observations.id });
+    const done = await db.update(observations).set({ topic: row.topic, classified: true, topicAt: /* @__PURE__ */ new Date() }).where(eq3(observations.id, row.id)).returning({ id: observations.id });
     changed += done.length;
   }
   return changed;
@@ -1579,7 +1761,7 @@ async function insertBeliefs(db, rows) {
   if (rows.length === 0) return [];
   const done = await db.insert(beliefs).values(
     rows.map((row) => ({
-      id: randomUUID(),
+      id: randomUUID2(),
       topic: row.topic,
       classified: row.classified ?? true,
       statement: row.statement,
@@ -1594,14 +1776,14 @@ async function insertBeliefs(db, rows) {
   return done.map((row) => row.id);
 }
 async function updateBelief(db, id, patch) {
-  const done = await db.update(beliefs).set({ ...patch, updatedAt: /* @__PURE__ */ new Date() }).where(and2(eq2(beliefs.id, id), eq2(beliefs.state, "inferred"))).returning({ id: beliefs.id });
+  const done = await db.update(beliefs).set({ ...patch, updatedAt: /* @__PURE__ */ new Date() }).where(and3(eq3(beliefs.id, id), eq3(beliefs.state, "inferred"))).returning({ id: beliefs.id });
   return done.length > 0;
 }
 async function listBeliefs(db, options = {}) {
   const filters = [];
-  if (options.topic !== void 0) filters.push(eq2(beliefs.topic, options.topic));
-  if (options.states !== void 0) filters.push(inArray2(beliefs.state, options.states));
-  const rows = await db.select().from(beliefs).where(filters.length > 0 ? and2(...filters) : void 0).orderBy(asc(beliefs.createdAt), asc(beliefs.id));
+  if (options.topic !== void 0) filters.push(eq3(beliefs.topic, options.topic));
+  if (options.states !== void 0) filters.push(inArray3(beliefs.state, options.states));
+  const rows = await db.select().from(beliefs).where(filters.length > 0 ? and3(...filters) : void 0).orderBy(asc2(beliefs.createdAt), asc2(beliefs.id));
   return rows.map((row) => ({
     ...row,
     state: row.state,
@@ -1622,26 +1804,31 @@ async function signBelief(db, id, statement) {
   const clean = statement?.replace(/\s+/g, " ").trim();
   const done = await db.update(beliefs).set({
     state: "signed",
-    signedAt: sql2`coalesce(${beliefs.signedAt}, now())`,
+    signedAt: sql3`coalesce(${beliefs.signedAt}, now())`,
     /*
       `updatedAt` only if the text really changes. Fixing one as is a gesture, and gestures are
       not churn from the machine: with the date moved, signing five beliefs without touching a
       word of them read as 'tuned: 5' in the weekly summary.
      */
-    ...clean ? { statement: clean, model: "", updatedAt: /* @__PURE__ */ new Date() } : {}
-  }).where(and2(eq2(beliefs.id, id), inArray2(beliefs.state, ALIVE))).returning({ id: beliefs.id });
+    // Editing an owner-authored rule stays authorship, not a correction of Twin's prediction.
+    ...clean ? {
+      statement: clean,
+      model: sql3`case when ${beliefs.model} = 'owner' then 'owner' else '' end`,
+      updatedAt: /* @__PURE__ */ new Date()
+    } : {}
+  }).where(and3(eq3(beliefs.id, id), inArray3(beliefs.state, ALIVE))).returning({ id: beliefs.id });
   return done.length > 0;
 }
 async function vetoBelief(db, id) {
-  const done = await db.update(beliefs).set({ state: "vetoed", vetoedAt: sql2`coalesce(${beliefs.vetoedAt}, now())` }).where(and2(eq2(beliefs.id, id), inArray2(beliefs.state, ALIVE))).returning({ id: beliefs.id });
+  const done = await db.update(beliefs).set({ state: "vetoed", vetoedAt: sql3`coalesce(${beliefs.vetoedAt}, now())` }).where(and3(eq3(beliefs.id, id), inArray3(beliefs.state, ALIVE))).returning({ id: beliefs.id });
   if (done.length === 0) return false;
-  const abiertas = await db.select({ id: beliefs.id, supersedes: beliefs.supersedes }).from(beliefs).where(eq2(beliefs.state, "proposed"));
+  const abiertas = await db.select({ id: beliefs.id, supersedes: beliefs.supersedes }).from(beliefs).where(eq3(beliefs.state, "proposed"));
   const tocadas = abiertas.filter(
     (one) => Array.isArray(one.supersedes) ? one.supersedes.includes(id) : false
   );
   if (tocadas.length > 0) {
     const vivas = new Set(
-      (await db.select({ id: beliefs.id }).from(beliefs).where(inArray2(beliefs.state, ALIVE))).map((row) => row.id)
+      (await db.select({ id: beliefs.id }).from(beliefs).where(inArray3(beliefs.state, ALIVE))).map((row) => row.id)
     );
     const huerfanas = tocadas.filter(
       (one) => one.supersedes.every(
@@ -1649,22 +1836,22 @@ async function vetoBelief(db, id) {
       )
     ).map((one) => one.id);
     if (huerfanas.length > 0) {
-      await db.update(beliefs).set({ state: "answered", retiredAt: sql2`coalesce(${beliefs.retiredAt}, now())` }).where(inArray2(beliefs.id, huerfanas));
+      await db.update(beliefs).set({ state: "answered", retiredAt: sql3`coalesce(${beliefs.retiredAt}, now())` }).where(inArray3(beliefs.id, huerfanas));
     }
   }
   return true;
 }
 async function retireBeliefs(db, ids) {
   if (ids.length === 0) return 0;
-  const done = await db.update(beliefs).set({ state: "retired", retiredAt: sql2`coalesce(${beliefs.retiredAt}, now())` }).where(and2(inArray2(beliefs.id, ids), eq2(beliefs.state, "inferred"))).returning({ id: beliefs.id });
+  const done = await db.update(beliefs).set({ state: "retired", retiredAt: sql3`coalesce(${beliefs.retiredAt}, now())` }).where(and3(inArray3(beliefs.id, ids), eq3(beliefs.state, "inferred"))).returning({ id: beliefs.id });
   return done.length;
 }
 async function setBeliefScope(db, id, identity) {
-  const done = await db.update(beliefs).set({ identity }).where(and2(eq2(beliefs.id, id), inArray2(beliefs.state, ALIVE))).returning({ id: beliefs.id });
+  const done = await db.update(beliefs).set({ identity }).where(and3(eq3(beliefs.id, id), inArray3(beliefs.state, ALIVE))).returning({ id: beliefs.id });
   return done.length > 0;
 }
 async function resolveProposal(db, id, accept) {
-  const [row] = await db.select().from(beliefs).where(and2(eq2(beliefs.id, id), eq2(beliefs.state, "proposed")));
+  const [row] = await db.select().from(beliefs).where(and3(eq3(beliefs.id, id), eq3(beliefs.state, "proposed")));
   if (!row) return false;
   const supersedes = Array.isArray(row.supersedes) ? row.supersedes.filter((one) => typeof one === "string") : [];
   let aplicado = !accept;
@@ -1689,22 +1876,22 @@ async function resolveProposal(db, id, accept) {
             accepted: a correction that occurred is not undone by a later agreement.
            */
           updatedAt: /* @__PURE__ */ new Date()
-        }).where(and2(eq2(beliefs.id, other), eq2(beliefs.state, "signed"))).returning({ id: beliefs.id });
+        }).where(and3(eq3(beliefs.id, other), eq3(beliefs.state, "signed"))).returning({ id: beliefs.id });
         if (done.length > 0) heredera = other;
         continue;
       }
-      await db.update(beliefs).set({ state: "retired", retiredAt: sql2`coalesce(${beliefs.retiredAt}, now())` }).where(and2(eq2(beliefs.id, other), eq2(beliefs.state, "signed")));
+      await db.update(beliefs).set({ state: "retired", retiredAt: sql3`coalesce(${beliefs.retiredAt}, now())` }).where(and3(eq3(beliefs.id, other), eq3(beliefs.state, "signed")));
     }
     aplicado = heredera !== void 0;
   }
-  await db.update(beliefs).set({ state: "answered", retiredAt: sql2`coalesce(${beliefs.retiredAt}, now())` }).where(eq2(beliefs.id, id));
+  await db.update(beliefs).set({ state: "answered", retiredAt: sql3`coalesce(${beliefs.retiredAt}, now())` }).where(eq3(beliefs.id, id));
   if (supersedes.length > 0) {
-    const abiertas = await db.select({ id: beliefs.id, supersedes: beliefs.supersedes }).from(beliefs).where(eq2(beliefs.state, "proposed"));
+    const abiertas = await db.select({ id: beliefs.id, supersedes: beliefs.supersedes }).from(beliefs).where(eq3(beliefs.state, "proposed"));
     const mismas = abiertas.filter(
       (one) => Array.isArray(one.supersedes) ? one.supersedes.some((other) => supersedes.includes(other)) : false
     ).map((one) => one.id);
     if (mismas.length > 0) {
-      await db.update(beliefs).set({ state: "answered", retiredAt: sql2`coalesce(${beliefs.retiredAt}, now())` }).where(inArray2(beliefs.id, mismas));
+      await db.update(beliefs).set({ state: "answered", retiredAt: sql3`coalesce(${beliefs.retiredAt}, now())` }).where(inArray3(beliefs.id, mismas));
     }
   }
   return aplicado;
@@ -1720,13 +1907,13 @@ function asPublished(value) {
 }
 async function markPublished(db, rows) {
   for (const row of rows) {
-    await db.update(beliefs).set({ publishedAs: row.published }).where(eq2(beliefs.id, row.id));
+    await db.update(beliefs).set({ publishedAs: row.published }).where(eq3(beliefs.id, row.id));
   }
 }
 async function setBeliefTopics(db, rows) {
   let changed = 0;
   for (const row of rows) {
-    const done = await db.update(beliefs).set({ topic: row.topic, classified: true }).where(eq2(beliefs.id, row.id)).returning({ id: beliefs.id });
+    const done = await db.update(beliefs).set({ topic: row.topic, classified: true }).where(eq3(beliefs.id, row.id)).returning({ id: beliefs.id });
     changed += done.length;
   }
   return changed;
@@ -1739,19 +1926,19 @@ function standsUp(support) {
   return support.days >= SUPPORT_FLOOR.sources || support.projects >= SUPPORT_FLOOR.sources;
 }
 async function tasteScore(db) {
-  const days = sql2.raw(String(SCORE_WINDOW_DAYS));
-  const twice = sql2.raw(String(SCORE_WINDOW_DAYS * 2));
-  const thrice = sql2.raw(String(SCORE_WINDOW_DAYS * 3));
-  const corrected = sql2.raw(
-    "(state = 'vetoed' or (state in ('signed', 'retired') and model = ''))"
+  const days = sql3.raw(String(SCORE_WINDOW_DAYS));
+  const twice = sql3.raw(String(SCORE_WINDOW_DAYS * 2));
+  const thrice = sql3.raw(String(SCORE_WINDOW_DAYS * 3));
+  const corrected = sql3.raw(
+    "(model <> 'owner' and (state = 'vetoed' or (state in ('signed', 'retired') and model = '')))"
   );
-  const dicha = sql2.raw("state not in ('proposed', 'answered')");
+  const dicha = sql3.raw("state not in ('proposed', 'answered') and model <> 'owner'");
   const [row] = await db.select({
-    alive: sql2`count(*) filter (where state in ('inferred', 'signed'))::int`,
-    signed: sql2`count(*) filter (where state = 'signed')::int`,
-    vetoed: sql2`count(*) filter (where state = 'vetoed')::int`,
-    retired: sql2`count(*) filter (where state = 'retired')::int`,
-    proposed: sql2`count(*) filter (where state = 'proposed')::int`,
+    alive: sql3`count(*) filter (where state in ('inferred', 'signed'))::int`,
+    signed: sql3`count(*) filter (where state = 'signed')::int`,
+    vetoed: sql3`count(*) filter (where state = 'vetoed')::int`,
+    retired: sql3`count(*) filter (where state = 'retired')::int`,
+    proposed: sql3`count(*) filter (where state = 'proposed')::int`,
     /*
       Everything except what was only asked, whether open (`proposed`) or answered (`answered`).
       A proposal has not been taught to anyone as a belief: it has been taught as a question,
@@ -1763,8 +1950,8 @@ async function tasteScore(db) {
       anything—in other words, the only product metric improved just by the act of answering
       questions.
      */
-    shown: sql2`count(*) filter (where state not in ('proposed', 'answered'))::int`,
-    corrections: sql2`count(*) filter (where ${corrected})::int`,
+    shown: sql3`count(*) filter (where ${dicha})::int`,
+    corrections: sql3`count(*) filter (where ${corrected})::int`,
     /*
       Two fifths go through one month: the middle one and the one before, not the one that goes.
       A newly born fifth has not finished being judged, and to compare it against a settled one
@@ -1775,19 +1962,19 @@ async function tasteScore(db) {
       sixty that already include them: always similar, never completely false, impossible to see
       on screen.
      */
-    recentShown: sql2`count(*) filter (
+    recentShown: sql3`count(*) filter (
         where ${dicha}
           and created_at > now() - interval '${twice} days'
           and created_at <= now() - interval '${days} days')::int`,
-    recentCorrections: sql2`count(*) filter (
+    recentCorrections: sql3`count(*) filter (
         where ${dicha} and ${corrected}
           and created_at > now() - interval '${twice} days'
           and created_at <= now() - interval '${days} days')::int`,
-    earlierShown: sql2`count(*) filter (
+    earlierShown: sql3`count(*) filter (
         where ${dicha}
           and created_at > now() - interval '${thrice} days'
           and created_at <= now() - interval '${twice} days')::int`,
-    earlierCorrections: sql2`count(*) filter (
+    earlierCorrections: sql3`count(*) filter (
         where ${dicha} and ${corrected}
           and created_at > now() - interval '${thrice} days'
           and created_at <= now() - interval '${twice} days')::int`
@@ -1809,8 +1996,9 @@ async function tasteScore(db) {
   const standing = alive.filter(
     (one) => one.state === "signed" || standsUp(one.support)
   ).length;
-  const apoyo = alive.reduce((total, one) => total + one.support.observations, 0);
-  const [evidence] = await db.select({ observations: sql2`count(*)::int` }).from(observations);
+  const learned = alive.filter((one) => one.model !== "owner");
+  const apoyo = learned.reduce((total, one) => total + one.support.observations, 0);
+  const [evidence] = await db.select({ observations: sql3`count(*)::int` }).from(observations);
   const observations2 = evidence?.observations ?? 0;
   const rate = rateOf(counts.corrections, counts.shown);
   const recent = windowOf(counts.recentShown, counts.recentCorrections);
@@ -1826,7 +2014,7 @@ async function tasteScore(db) {
     observations: observations2,
     // With one decimal: the difference between 1.0 and 1.4 is the difference between copying and
     // synthesizing, and a whole number would teach them as the same number.
-    density: counts.alive === 0 ? null : Math.round(apoyo * 10 / counts.alive) / 10,
+    density: learned.length === 0 ? null : Math.round(apoyo * 10 / learned.length) / 10,
     corrections: counts.corrections,
     shown: counts.shown,
     rate,
@@ -1844,19 +2032,19 @@ function windowOf(shown, corrections) {
   return { shown, corrections, rate: rateOf(corrections, shown) };
 }
 async function briefScore(db) {
-  const [total] = await db.select({ findings: sql2`coalesce(sum(jsonb_array_length(${looks.findings})), 0)::int` }).from(looks);
+  const [total] = await db.select({ findings: sql3`coalesce(sum(jsonb_array_length(${looks.findings})), 0)::int` }).from(looks);
   const [used] = await db.select({
-    tasks: sql2`count(*)::int`,
-    claimed: sql2`count(*) filter (where ${tasks.claimedAt} is not null)::int`,
-    done: sql2`count(*) filter (where ${tasks.status} = 'done')::int`
-  }).from(tasks).where(and2(isNotNull(tasks.fromLook), isNotNull(tasks.fromFinding)));
+    tasks: sql3`count(*)::int`,
+    claimed: sql3`count(*) filter (where ${tasks.claimedAt} is not null)::int`,
+    done: sql3`count(*) filter (where ${tasks.status} = 'done')::int`
+  }).from(tasks).where(and3(isNotNull(tasks.fromLook), isNotNull(tasks.fromFinding)));
   const pairs = await db.select({
-    alive: sql2`count(*) filter (where ${tasks.status} <> 'discarded')::int`
-  }).from(tasks).where(and2(isNotNull(tasks.fromLook), isNotNull(tasks.fromFinding))).groupBy(tasks.fromLook, tasks.fromFinding);
+    alive: sql3`count(*) filter (where ${tasks.status} <> 'discarded')::int`
+  }).from(tasks).where(and3(isNotNull(tasks.fromLook), isNotNull(tasks.fromFinding))).groupBy(tasks.fromLook, tasks.fromFinding);
   const out = await db.select({
-    launched: sql2`count(distinct ${launches.taskId})::int`,
-    launches: sql2`count(*)::int`
-  }).from(launches).innerJoin(tasks, eq2(tasks.id, launches.taskId)).where(and2(isNotNull(tasks.fromLook), isNotNull(tasks.fromFinding)));
+    launched: sql3`count(distinct ${launches.taskId})::int`,
+    launches: sql3`count(*)::int`
+  }).from(launches).innerJoin(tasks, eq3(tasks.id, launches.taskId)).where(and3(isNotNull(tasks.fromLook), isNotNull(tasks.fromFinding)));
   const findings = total?.findings ?? 0;
   const ordered = pairs.filter((pair) => pair.alive > 0).length;
   return {
@@ -1878,10 +2066,12 @@ function readingOf(rate, recent, previous) {
 }
 async function saveModelCall(db, call) {
   await db.insert(modelCalls).values({
-    id: randomUUID(),
+    id: randomUUID2(),
     kind: call.kind,
     provider: call.provider,
     model: call.model,
+    appId: call.appId ?? null,
+    appJobId: call.appJobId ?? null,
     identity: call.identity ?? null,
     inputTokens: call.input ?? null,
     outputTokens: call.output ?? null,
@@ -1895,17 +2085,43 @@ async function modelSpendToday(db, kind, since = startOfDay()) {
   const none = { calls: 0, input: 0, output: 0, unmetered: 0, images: 0 };
   const kinds = typeof kind === "string" ? [kind] : kind;
   if (kinds.length === 0) return none;
-  const [row] = await db.select(SPEND).from(modelCalls).where(and2(inArray2(modelCalls.kind, [...kinds]), gte(modelCalls.createdAt, since)));
+  const [row] = await db.select(SPEND).from(modelCalls).where(and3(inArray3(modelCalls.kind, [...kinds]), gte2(modelCalls.createdAt, since)));
   return row ?? none;
 }
-async function modelSpendByKind(db, since = startOfDay()) {
-  return db.select({ kind: modelCalls.kind, ...SPEND }).from(modelCalls).where(gte(modelCalls.createdAt, since)).groupBy(modelCalls.kind).orderBy(asc(modelCalls.kind));
+async function modelSpendByKind(db, since = startOfDay(), until) {
+  return db.select({ kind: modelCalls.kind, ...SPEND }).from(modelCalls).where(inWindow(since, until)).groupBy(modelCalls.kind).orderBy(asc2(modelCalls.kind));
+}
+async function modelSpendByModel(db, since = startOfDay(), until) {
+  return db.select({ provider: modelCalls.provider, model: modelCalls.model, ...SPEND }).from(modelCalls).where(inWindow(since, until)).groupBy(modelCalls.provider, modelCalls.model).orderBy(asc2(modelCalls.provider), asc2(modelCalls.model));
+}
+async function listModelCalls(db, options) {
+  const rows = await db.select({
+    kind: modelCalls.kind,
+    provider: modelCalls.provider,
+    model: modelCalls.model,
+    identity: modelCalls.identity,
+    input: modelCalls.inputTokens,
+    output: modelCalls.outputTokens,
+    images: modelCalls.images,
+    createdAt: modelCalls.createdAt
+  }).from(modelCalls).where(inWindow(options.since, options.until)).orderBy(asc2(modelCalls.createdAt), asc2(modelCalls.id)).limit(options.limit ?? 2e4);
+  return rows;
+}
+function inWindow(since, until) {
+  return until ? and3(gte2(modelCalls.createdAt, since), lt(modelCalls.createdAt, until)) : gte2(modelCalls.createdAt, since);
+}
+async function latestSynthesisByTopic(db) {
+  const rows = await db.select({
+    topic: synthesisPasses.topic,
+    at: sql3`extract(epoch from max(${synthesisPasses.at}))::double precision`
+  }).from(synthesisPasses).groupBy(synthesisPasses.topic);
+  return new Map(rows.map((row) => [row.topic, row.at * 1e3]));
 }
 async function saveSynthesisPass(db, pass) {
-  await db.insert(synthesisPasses).values({ id: randomUUID(), ...pass });
+  await db.insert(synthesisPasses).values({ id: randomUUID2(), ...pass });
 }
 async function beliefChurn(db, since) {
-  const rows = await db.select().from(synthesisPasses).where(gte(synthesisPasses.at, since)).orderBy(desc(synthesisPasses.at));
+  const rows = await db.select().from(synthesisPasses).where(gte2(synthesisPasses.at, since)).orderBy(desc2(synthesisPasses.at));
   const byMonth = /* @__PURE__ */ new Map();
   for (const row of rows) {
     const month = monthOf(row.at);
@@ -1927,20 +2143,20 @@ function startOfMonthsAgo(n, at = /* @__PURE__ */ new Date()) {
   return new Date(at.getFullYear(), at.getMonth() - n, 1);
 }
 var SPEND = {
-  calls: sql2`count(*)::int`,
+  calls: sql3`count(*)::int`,
   // `coalesce` about the sum and not about each row: a table without rows today sums to zero, and
   // there the zero is indeed the correct answer.
-  input: sql2`coalesce(sum(input_tokens), 0)::int`,
-  output: sql2`coalesce(sum(output_tokens), 0)::int`,
-  unmetered: sql2`count(*) filter (where input_tokens is null)::int`,
-  images: sql2`coalesce(sum(images), 0)::int`
+  input: sql3`coalesce(sum(input_tokens), 0)::int`,
+  output: sql3`coalesce(sum(output_tokens), 0)::int`,
+  unmetered: sql3`count(*) filter (where input_tokens is null)::int`,
+  images: sql3`coalesce(sum(images), 0)::int`
 };
 async function inTransaction(db, run) {
   return db.transaction(async (tx) => run(tx));
 }
 async function citedVerdictIds(db) {
   const rows = await db.select({
-    verdictId: sql2`jsonb_array_elements(${observations.citations})->>'verdictId'`
+    verdictId: sql3`jsonb_array_elements(${observations.citations})->>'verdictId'`
   }).from(observations);
   const ids = /* @__PURE__ */ new Set();
   for (const row of rows) if (row.verdictId) ids.add(row.verdictId);
@@ -1948,7 +2164,7 @@ async function citedVerdictIds(db) {
 }
 async function markVerdictsDistilled(db, ids) {
   if (ids.length === 0) return;
-  await db.update(verdicts).set({ distilledAt: sql2`coalesce(${verdicts.distilledAt}, now())` }).where(inArray2(verdicts.id, ids));
+  await db.update(verdicts).set({ distilledAt: sql3`coalesce(${verdicts.distilledAt}, now())` }).where(inArray3(verdicts.id, ids));
 }
 async function readVerdictIds(db) {
   const marked = await db.select({ id: verdicts.id }).from(verdicts).where(isNotNull(verdicts.distilledAt));
@@ -1958,8 +2174,8 @@ async function readVerdictIds(db) {
 }
 async function tasteReach(db) {
   const [row] = await db.select({
-    projects: sql2`count(*)::int`,
-    reached: sql2`count(*) filter (where exists (
+    projects: sql3`count(*)::int`,
+    reached: sql3`count(*) filter (where exists (
         select 1 from jsonb_array_elements(coalesce(${projects.agentsMd}->'files', '[]'::jsonb)) f
         where (f->>'managed')::boolean
       ))::int`
@@ -1967,15 +2183,27 @@ async function tasteReach(db) {
   return { projects: row?.projects ?? 0, reached: row?.reached ?? 0 };
 }
 async function corpusProgress(db) {
-  const [row] = await db.select({ total: sql2`count(*)::int` }).from(verdicts);
+  const [row] = await db.select({ total: sql3`count(*)::int` }).from(verdicts);
   const total = row?.total ?? 0;
   const leidos = await readVerdictIds(db);
-  if (leidos.size === 0) return { total, read: 0 };
-  const vivos = await db.select({ id: verdicts.id }).from(verdicts);
+  const vivos = await db.select({ id: verdicts.id, identity: verdicts.identity, accepted: verdicts.accepted }).from(verdicts);
   let read = 0;
-  for (const row2 of vivos) if (leidos.has(row2.id)) read += 1;
-  return { total, read };
+  let rejected = 0;
+  const unreadByProject = /* @__PURE__ */ new Map();
+  for (const row2 of vivos) {
+    if (leidos.has(row2.id)) {
+      read += 1;
+    } else if (row2.accepted === false) {
+      rejected += 1;
+    } else {
+      unreadByProject.set(row2.identity, (unreadByProject.get(row2.identity) ?? 0) + 1);
+    }
+  }
+  let thin = 0;
+  for (const count of unreadByProject.values()) if (count < MIN_DISTILL_CITATIONS) thin += count;
+  return { total: Math.max(total - thin - rejected, read), read };
 }
+var MIN_DISTILL_CITATIONS = 2;
 async function remapObservations(db) {
   const rows = await db.select({
     id: observations.id,
@@ -1992,7 +2220,7 @@ async function remapObservations(db) {
     for (const id of ids) wanted.add(id);
   }
   if (wanted.size === 0) return 0;
-  const verdicts2 = await db.select({ id: verdicts.id, identity: verdicts.identity }).from(verdicts).where(inArray2(verdicts.id, [...wanted]));
+  const verdicts2 = await db.select({ id: verdicts.id, identity: verdicts.identity }).from(verdicts).where(inArray3(verdicts.id, [...wanted]));
   const identityOf = new Map(verdicts2.map((row) => [row.id, row.identity]));
   let changed = 0;
   for (const row of rows) {
@@ -2013,7 +2241,7 @@ async function remapObservations(db) {
       }
     }
     if (best === void 0 || best === row.identity) continue;
-    await db.update(observations).set({ identity: best }).where(eq2(observations.id, row.id));
+    await db.update(observations).set({ identity: best }).where(eq3(observations.id, row.id));
     changed += 1;
   }
   return changed;
@@ -2038,7 +2266,7 @@ async function saveReview(db, projectId, report) {
   await db.insert(reviews).values({ projectId, ...value }).onConflictDoUpdate({ target: reviews.projectId, set: value });
 }
 async function getReview(db, projectId) {
-  const [row] = await db.select().from(reviews).where(eq2(reviews.projectId, projectId)).limit(1);
+  const [row] = await db.select().from(reviews).where(eq3(reviews.projectId, projectId)).limit(1);
   if (row === void 0) return void 0;
   return {
     findings: storedCritiques(row.findings),
@@ -2052,7 +2280,7 @@ async function neverReviewed(db, limit) {
     id: projects.id,
     root: projects.root,
     lastCommitAt: projects.lastCommitAt
-  }).from(projects).leftJoin(reviews, eq2(reviews.projectId, projects.id)).where(isNull(reviews.projectId)).orderBy(sql2`${projects.lastCommitAt} desc nulls last`).limit(limit);
+  }).from(projects).leftJoin(reviews, eq3(reviews.projectId, projects.id)).where(isNull(reviews.projectId)).orderBy(sql3`${projects.lastCommitAt} desc nulls last`).limit(limit);
 }
 function storedCritiques(value) {
   if (!Array.isArray(value)) return [];
@@ -2072,7 +2300,7 @@ function storedCritiques(value) {
   return findings;
 }
 async function saveLook(db, look) {
-  const id = randomUUID();
+  const id = randomUUID2();
   await db.insert(looks).values({
     id,
     identity: look.identity,
@@ -2090,12 +2318,12 @@ async function saveLook(db, look) {
   return id;
 }
 async function lookedAt(db, identity, digest) {
-  const [row] = await db.select({ id: looks.id }).from(looks).where(and2(eq2(looks.identity, identity), eq2(looks.digest, digest))).limit(1);
+  const [row] = await db.select({ id: looks.id }).from(looks).where(and3(eq3(looks.identity, identity), eq3(looks.digest, digest))).limit(1);
   return row !== void 0;
 }
 async function listLooks(db, options = {}) {
-  const query = db.select().from(looks).orderBy(desc(looks.at)).limit(options.limit ?? 20);
-  const rows = options.identity ? await query.where(eq2(looks.identity, options.identity)) : await query;
+  const query = db.select().from(looks).orderBy(desc2(looks.at)).limit(options.limit ?? 20);
+  const rows = options.identity ? await query.where(eq3(looks.identity, options.identity)) : await query;
   return rows.map((row) => ({
     id: row.id,
     identity: row.identity,
@@ -2113,7 +2341,7 @@ async function listLooks(db, options = {}) {
   }));
 }
 async function getLook(db, id) {
-  const [row] = await db.select().from(looks).where(eq2(looks.id, id)).limit(1);
+  const [row] = await db.select().from(looks).where(eq3(looks.id, id)).limit(1);
   if (row === void 0) return void 0;
   return {
     id: row.id,
@@ -2137,11 +2365,11 @@ async function projectByIdentity(db, identity) {
     name: projects.name,
     slug: projects.slug,
     root: projects.root
-  }).from(projects).where(eq2(projects.identity, identity)).orderBy(sql2`${projects.lastCommitAt} desc nulls last`, asc(projects.root)).limit(1);
+  }).from(projects).where(eq3(projects.identity, identity)).orderBy(sql3`${projects.lastCommitAt} desc nulls last`, asc2(projects.root)).limit(1);
   return row;
 }
 async function autoLooksToday(db, since = startOfDay()) {
-  const [row] = await db.select({ n: sql2`count(*)::int` }).from(looks).where(and2(eq2(looks.fired, "watch"), gte(looks.at, since)));
+  const [row] = await db.select({ n: sql3`count(*)::int` }).from(looks).where(and3(eq3(looks.fired, "watch"), gte2(looks.at, since)));
   return row?.n ?? 0;
 }
 function storedFindings(value) {
@@ -2159,23 +2387,53 @@ function storedFindings(value) {
   }
   return findings;
 }
+async function getOpenContext(db, id) {
+  const [project] = await db.select({
+    id: projects.id,
+    name: projects.name,
+    slug: projects.slug,
+    root: projects.root,
+    identity: projects.identity,
+    gitRemoteUrl: projects.gitRemoteUrl,
+    runbook: projects.runbook
+  }).from(projects).where(eq3(projects.id, id)).limit(1);
+  if (!project) return void 0;
+  const [decision] = project.identity ? await db.select({ accounts: decisions.accounts, openPlan: decisions.openPlan }).from(decisions).where(eq3(decisions.identity, project.identity)).limit(1) : [];
+  const [links, distributions2] = await Promise.all([
+    db.select().from(projectLinks).where(eq3(projectLinks.projectId, project.id)).orderBy(projectLinks.kind, projectLinks.service),
+    db.select().from(distributions).where(eq3(distributions.projectId, project.id))
+  ]);
+  return { project, decision: decision ?? null, links, distributions: distributions2 };
+}
+async function saveOpenPlan(db, id, plan) {
+  const [project] = await db.select({ identity: projects.identity, name: projects.name }).from(projects).where(eq3(projects.id, id)).limit(1);
+  if (!project?.identity) return false;
+  const value = { openPlan: plan, lastName: project.name };
+  await db.insert(decisions).values({ identity: project.identity, ...value }).onConflictDoUpdate({ target: decisions.identity, set: { ...value, updatedAt: /* @__PURE__ */ new Date() } });
+  return true;
+}
 
 // src/agents.ts
-import { createHash as createHash2, randomBytes } from "crypto";
-import { and as and4, asc as asc3, desc as desc3, eq as eq4, inArray as inArray4, isNotNull as isNotNull2, or as or3, sql as sql4 } from "drizzle-orm";
+import { createHash as createHash3, randomBytes } from "crypto";
+import { and as and5, asc as asc4, desc as desc4, eq as eq5, inArray as inArray5, isNotNull as isNotNull2, or as or3, sql as sql5 } from "drizzle-orm";
 import { agentKindAliases, canonicalAgentKind, redactSecrets as redactSecrets2 } from "@panoma/core";
 
 // src/notes.ts
-import { and as and3, asc as asc2, desc as desc2, eq as eq3, inArray as inArray3, sql as sql3 } from "drizzle-orm";
+import { and as and4, asc as asc3, desc as desc3, eq as eq4, inArray as inArray4, sql as sql4 } from "drizzle-orm";
 import { redactSecrets } from "@panoma/core";
 var NOTE_MAX = 500;
 var NOTE_BUDGET = 2e3;
 var NOTE_PENDING_MAX = 20;
 var NOTE_SLEEPING_MAX = 30;
-var TRIGGER_SHAPE = /^[\p{L}\p{N}_.@-]+(?:\/[\p{L}\p{N}_.@-]+)*(?:\/\*\*)?$/u;
 var TRIGGER_MAX = 120;
+function validMemoryPath(path) {
+  if (!path || path.length > 2048 || path !== path.trim() || /^[A-Za-z]:/.test(path)) return false;
+  if (path.includes("\\") || path.includes("*") || /\p{Cc}/u.test(path)) return false;
+  return path.split("/").every((segment) => segment.trim() !== "" && segment !== "." && segment !== "..");
+}
 function validTrigger(trigger) {
-  return trigger.length <= TRIGGER_MAX && TRIGGER_SHAPE.test(trigger) && !trigger.split("/").includes("..");
+  const path = trigger.endsWith("/**") ? trigger.slice(0, -3) : trigger;
+  return trigger.length <= TRIGGER_MAX && validMemoryPath(path);
 }
 function triggerMatches(trigger, path) {
   if (trigger.endsWith("/**")) {
@@ -2184,6 +2442,9 @@ function triggerMatches(trigger, path) {
   }
   return path === trigger;
 }
+async function lockNoteProject(db, projectId) {
+  await db.select({ id: projects.id }).from(projects).where(eq4(projects.id, projectId)).for("update");
+}
 async function proposeNote(db, input) {
   const body = redactSecrets(input.body.trim());
   if (body.length === 0 || body.length > NOTE_MAX) return { refused: "tooLong", max: NOTE_MAX };
@@ -2191,53 +2452,80 @@ async function proposeNote(db, input) {
   if (trigger !== void 0 && trigger !== "" && !validTrigger(trigger)) {
     return { refused: "badTrigger" };
   }
-  const [row] = await db.select({ pending: sql3`count(*)::int` }).from(notes).where(and3(eq3(notes.projectId, input.projectId), eq3(notes.status, "proposed")));
-  const pending = row?.pending ?? 0;
-  if (pending >= NOTE_PENDING_MAX) return { refused: "pendingFull", max: NOTE_PENDING_MAX };
-  const id = newId("note");
-  await db.insert(notes).values({
-    id,
-    projectId: input.projectId,
-    body,
-    createdBy: input.createdBy,
-    trigger: trigger || null
+  return db.transaction(async (tx) => {
+    await lockNoteProject(tx, input.projectId);
+    const [row] = await tx.select({ pending: sql4`count(*)::int` }).from(notes).where(and4(eq4(notes.projectId, input.projectId), eq4(notes.status, "proposed")));
+    const pending = row?.pending ?? 0;
+    if (pending >= NOTE_PENDING_MAX) return { refused: "pendingFull", max: NOTE_PENDING_MAX };
+    const id = newId("note");
+    await tx.insert(notes).values({
+      id,
+      projectId: input.projectId,
+      body,
+      createdBy: input.createdBy,
+      trigger: trigger || null
+    });
+    return { id, pending: pending + 1 };
   });
-  return { id, pending: pending + 1 };
 }
 async function addHumanNote(db, input) {
   const body = redactSecrets(input.body.trim());
   if (body.length === 0 || body.length > NOTE_MAX) return { refused: "tooLong", max: NOTE_MAX };
-  const { used } = await noteUsage(db, input.projectId);
-  if (used + body.length > NOTE_BUDGET) {
-    return { refused: "overBudget", used, budget: NOTE_BUDGET };
-  }
-  const id = newId("note");
-  await db.insert(notes).values({
-    id,
-    projectId: input.projectId,
-    body,
-    status: "approved",
-    createdBy: "human",
-    decidedAt: /* @__PURE__ */ new Date()
+  const trigger = input.trigger?.trim() || null;
+  if (trigger !== null && !validTrigger(trigger)) return { refused: "badTrigger" };
+  return db.transaction(async (tx) => {
+    await lockNoteProject(tx, input.projectId);
+    const usage = await noteUsage(tx, input.projectId);
+    if (trigger === null && usage.used + body.length > NOTE_BUDGET) {
+      return { refused: "overBudget", used: usage.used, budget: NOTE_BUDGET };
+    }
+    if (trigger !== null && usage.sleeping >= NOTE_SLEEPING_MAX) {
+      return { refused: "sleepingFull", used: usage.sleeping, budget: NOTE_SLEEPING_MAX };
+    }
+    const id = newId("note");
+    await tx.insert(notes).values({
+      id,
+      projectId: input.projectId,
+      body,
+      trigger,
+      status: "approved",
+      createdBy: "human",
+      decidedAt: /* @__PURE__ */ new Date(),
+      sentinels: input.sentinels ?? []
+    });
+    return { id, body };
   });
-  return { id };
 }
-async function decideNote(db, noteId, decision) {
+async function decideNote(db, noteId, decision, options = {}) {
   const from = decision === "approved" ? ["proposed", "challenged"] : ["proposed", "approved", "challenged"];
-  if (decision === "approved") {
-    const [note] = await db.select({ projectId: notes.projectId, body: notes.body, trigger: notes.trigger }).from(notes).where(and3(eq3(notes.id, noteId), inArray3(notes.status, ["proposed", "challenged"]))).limit(1);
+  return db.transaction(async (tx) => {
+    const [owner] = await tx.select({ projectId: notes.projectId }).from(notes).where(and4(
+      eq4(notes.id, noteId),
+      options.projectId === void 0 ? void 0 : eq4(notes.projectId, options.projectId)
+    )).limit(1);
+    if (!owner) return { decided: false, reason: "gone" };
+    await lockNoteProject(tx, owner.projectId);
+    const [note] = await tx.select({ body: notes.body, trigger: notes.trigger, decidedAt: notes.decidedAt }).from(notes).where(and4(eq4(notes.id, noteId), eq4(notes.projectId, owner.projectId), inArray4(notes.status, from))).limit(1);
     if (!note) return { decided: false, reason: "gone" };
-    const usage = await noteUsage(db, note.projectId);
-    if (note.trigger === null && usage.used + note.body.length > NOTE_BUDGET) {
-      return { decided: false, reason: "overBudget", used: usage.used, budget: NOTE_BUDGET };
-    }
-    if (note.trigger !== null && usage.sleeping >= NOTE_SLEEPING_MAX) {
-      return { decided: false, reason: "sleepingFull", used: usage.sleeping, budget: NOTE_SLEEPING_MAX };
+    if (decision === "approved") {
+      const usage = await noteUsage(tx, owner.projectId);
+      if (note.trigger === null && usage.used + note.body.length > NOTE_BUDGET) {
+        return { decided: false, reason: "overBudget", used: usage.used, budget: NOTE_BUDGET };
+      }
+      if (note.trigger !== null && usage.sleeping >= NOTE_SLEEPING_MAX) {
+        return { decided: false, reason: "sleepingFull", used: usage.sleeping, budget: NOTE_SLEEPING_MAX };
+      }
     }
-  }
-  const moved = await db.update(notes).set({ status: decision, decidedAt: /* @__PURE__ */ new Date(), ...decision === "approved" ? { challenge: null } : {} }).where(and3(eq3(notes.id, noteId), inArray3(notes.status, from))).returning({ id: notes.id, body: notes.body, trigger: notes.trigger });
-  if (moved.length === 0) return { decided: false, reason: "gone" };
-  return decision === "approved" ? { decided: true, body: moved[0]?.body, trigger: moved[0]?.trigger ?? null } : { decided: true };
+    const decidedAt = new Date(Math.max(Date.now(), (note.decidedAt?.getTime() ?? 0) + 1));
+    const moved = await tx.update(notes).set({
+      status: decision,
+      decidedAt,
+      ...decision === "approved" ? { challenge: null } : {},
+      ...decision === "approved" && options.sentinels !== void 0 ? { sentinels: options.sentinels } : {}
+    }).where(and4(eq4(notes.id, noteId), eq4(notes.projectId, owner.projectId), inArray4(notes.status, from))).returning({ id: notes.id, body: notes.body, trigger: notes.trigger });
+    if (moved.length === 0) return { decided: false, reason: "gone" };
+    return decision === "approved" ? { decided: true, body: moved[0]?.body, trigger: moved[0]?.trigger ?? null } : { decided: true };
+  });
 }
 async function listProjectNotes(db, projectId, statuses = ["approved"]) {
   return db.select({
@@ -2251,24 +2539,22 @@ async function listProjectNotes(db, projectId, statuses = ["approved"]) {
       The lawsuit travels with the row: the card shows the diff of the basis. It does not reach
       the agents' channel — `getAgentContext` chooses its fields and this is not among them.
      */
-    challenge: notes.challenge
-  }).from(notes).where(and3(eq3(notes.projectId, projectId), inArray3(notes.status, statuses))).orderBy(desc2(notes.createdAt), asc2(notes.id));
+    challenge: notes.challenge,
+    sentinels: notes.sentinels
+  }).from(notes).where(and4(eq4(notes.projectId, projectId), inArray4(notes.status, statuses))).orderBy(desc3(notes.createdAt), asc3(notes.id));
 }
 async function noteUsage(db, projectId) {
-  const [row] = await db.select({
-    /* Only the awake ones pay their share: a sleeping one does not travel in it. */
-    used: sql3`coalesce(sum(length(${notes.body})) filter (where ${notes.status} = 'approved' and ${notes.trigger} is null), 0)::int`,
-    count: sql3`count(*) filter (where ${notes.status} = 'approved' and ${notes.trigger} is null)::int`,
-    sleeping: sql3`count(*) filter (where ${notes.status} = 'approved' and ${notes.trigger} is not null)::int`,
-    pending: sql3`count(*) filter (where ${notes.status} = 'proposed')::int`
-  }).from(notes).where(eq3(notes.projectId, projectId));
-  return {
-    used: row?.used ?? 0,
-    budget: NOTE_BUDGET,
-    count: row?.count ?? 0,
-    sleeping: row?.sleeping ?? 0,
-    pending: row?.pending ?? 0
-  };
+  const rows = await db.select({ body: notes.body, status: notes.status, trigger: notes.trigger }).from(notes).where(and4(eq4(notes.projectId, projectId), inArray4(notes.status, ["approved", "proposed"])));
+  const usage = { used: 0, budget: NOTE_BUDGET, count: 0, sleeping: 0, pending: 0 };
+  for (const row of rows) {
+    if (row.status === "proposed") usage.pending++;
+    else if (row.trigger !== null) usage.sleeping++;
+    else {
+      usage.used += row.body.length;
+      usage.count++;
+    }
+  }
+  return usage;
 }
 async function notesAt(db, projectId, path) {
   const sleeping = await db.select({
@@ -2279,20 +2565,24 @@ async function notesAt(db, projectId, path) {
     createdAt: notes.createdAt,
     trigger: notes.trigger
   }).from(notes).where(
-    and3(eq3(notes.projectId, projectId), eq3(notes.status, "approved"), sql3`${notes.trigger} is not null`)
-  ).orderBy(desc2(notes.createdAt), asc2(notes.id));
+    and4(eq4(notes.projectId, projectId), eq4(notes.status, "approved"), sql4`${notes.trigger} is not null`)
+  ).orderBy(desc3(notes.createdAt), asc3(notes.id));
   return sleeping.filter((note) => note.trigger !== null && triggerMatches(note.trigger, path));
 }
 async function setSentinels(db, noteId, sentinels) {
-  await db.update(notes).set({ sentinels }).where(and3(eq3(notes.id, noteId), inArray3(notes.status, ["proposed", "approved", "challenged"])));
-}
-async function challengeNote(db, noteId, challenge) {
-  const moved = await db.update(notes).set({ status: "challenged", challenge }).where(and3(eq3(notes.id, noteId), eq3(notes.status, "approved"))).returning({ id: notes.id });
+  await db.update(notes).set({ sentinels }).where(and4(eq4(notes.id, noteId), inArray4(notes.status, ["proposed", "approved", "challenged"])));
+}
+async function challengeNote(db, noteId, challenge, expectedDecidedAt) {
+  const moved = await db.update(notes).set({ status: "challenged", challenge }).where(and4(
+    eq4(notes.id, noteId),
+    eq4(notes.status, "approved"),
+    expectedDecidedAt === void 0 ? void 0 : sql4`${notes.decidedAt} is not distinct from ${expectedDecidedAt}`
+  )).returning({ id: notes.id });
   return moved.length > 0;
 }
 async function listSentinels(db, projectId) {
-  const rows = await db.select({ id: notes.id, body: notes.body, sentinels: notes.sentinels }).from(notes).where(and3(eq3(notes.projectId, projectId), eq3(notes.status, "approved")));
-  return rows.map((row) => ({ id: row.id, body: row.body, sentinels: row.sentinels ?? [] })).filter((row) => row.sentinels.length > 0);
+  const rows = await db.select({ id: notes.id, body: notes.body, sentinels: notes.sentinels, decidedAt: notes.decidedAt }).from(notes).where(and4(eq4(notes.projectId, projectId), eq4(notes.status, "approved")));
+  return rows.map((row) => ({ id: row.id, body: row.body, sentinels: row.sentinels ?? [], decidedAt: row.decidedAt })).filter((row) => row.sentinels.length > 0);
 }
 async function recordServing(db, input) {
   await db.insert(servings).values({
@@ -2300,21 +2590,22 @@ async function recordServing(db, input) {
     projectId: input.projectId,
     agentId: input.agentId,
     arm: input.arm,
+    experimentId: input.experimentId ?? null,
     noteIds: input.noteIds,
     noteChars: input.noteChars
   });
 }
-async function scaleReport(db, days = 30) {
+async function scaleReport(db, days = 30, experimentId = "memory-v1") {
   const since = new Date(Date.now() - days * 864e5);
   const arms = await db.select({
     arm: servings.arm,
-    servings: sql3`count(*)::int`,
+    servings: sql4`count(*)::int`,
     /*
       The day in explicit UTC: the arm is distributed by UTC date, and `date_trunc` by itself
       would truncate in the session zone — two different calendars counting the same unit.
      */
-    visits: sql3`count(distinct (${servings.agentId} || ':' || ${servings.projectId} || ':' || ((${servings.at} at time zone 'UTC')::date)))::int`,
-    projects: sql3`count(distinct ${servings.projectId})::int`,
+    visits: sql4`count(distinct (${servings.agentId} || ':' || ${servings.projectId} || ':' || ((${servings.at} at time zone 'UTC')::date)))::int`,
+    projects: sql4`count(distinct ${servings.projectId})::int`,
     /*
       Qualified by hand and not with `${t.servings.at}`: drizzle emits the columns of the outer
       select WITHOUT their table ("at" by itself), and inside the subquery that name is captured
@@ -2324,30 +2615,32 @@ async function scaleReport(db, days = 30) {
       re-drawn then, and what is launched already re-drawn is the yield of that day's arm, not
       of this one.
      */
-    launchesAfter: sql3`sum((
+    launchesAfter: sql4`sum((
         select count(*) from ${launches} l
         where l.project_id = servings.project_id
           and l.at > servings.at
           and (l.at at time zone 'UTC')::date = (servings.at at time zone 'UTC')::date
       ))::int`
-  }).from(servings).where(sql3`${servings.at} >= ${since}`).groupBy(servings.arm).orderBy(asc2(servings.arm));
+  }).from(servings).where(and4(sql4`${servings.at} >= ${since}`, eq4(servings.experimentId, experimentId))).groupBy(servings.arm).orderBy(asc3(servings.arm));
+  const [observational] = await db.select({ count: sql4`count(*)::int` }).from(servings).where(and4(sql4`${servings.at} >= ${since}`, sql4`${servings.experimentId} is null`));
   const [gate] = await db.select({
-    pending: sql3`count(*) filter (where ${notes.status} = 'proposed')::int`,
-    oldestPendingDays: sql3`floor(extract(epoch from now() - min(${notes.createdAt}) filter (where ${notes.status} = 'proposed')) / 86400)::int`,
+    pending: sql4`count(*) filter (where ${notes.status} = 'proposed')::int`,
+    oldestPendingDays: sql4`floor(extract(epoch from now() - min(${notes.createdAt}) filter (where ${notes.status} = 'proposed')) / 86400)::int`,
     /*
       `decided` requires the state in addition to the date: one approved in a window that a
       sentinel later challenged keeps its decidedAt without being in any breakdown anymore, and
       the report's arithmetic must balance — decided = approved + discarded.
      */
-    decided: sql3`count(*) filter (where ${notes.decidedAt} >= ${since} and ${notes.status} in ('approved', 'discarded'))::int`,
-    approved: sql3`count(*) filter (where ${notes.decidedAt} >= ${since} and ${notes.status} = 'approved')::int`,
-    discarded: sql3`count(*) filter (where ${notes.decidedAt} >= ${since} and ${notes.status} = 'discarded')::int`,
-    medianHoursToDecision: sql3`round((percentile_cont(0.5) within group (
+    decided: sql4`count(*) filter (where ${notes.decidedAt} >= ${since} and ${notes.status} in ('approved', 'discarded'))::int`,
+    approved: sql4`count(*) filter (where ${notes.decidedAt} >= ${since} and ${notes.status} = 'approved')::int`,
+    discarded: sql4`count(*) filter (where ${notes.decidedAt} >= ${since} and ${notes.status} = 'discarded')::int`,
+    medianHoursToDecision: sql4`round((percentile_cont(0.5) within group (
         order by extract(epoch from ${notes.decidedAt} - ${notes.createdAt})
       ) filter (where ${notes.decidedAt} >= ${since}) / 3600)::numeric, 1)::float`
   }).from(notes);
   return {
     days,
+    observationalServings: observational?.count ?? 0,
     arms: arms.map((row) => ({
       arm: row.arm,
       servings: row.servings,
@@ -2367,14 +2660,14 @@ async function scaleReport(db, days = 30) {
 }
 async function bridgeCounts(db) {
   const [row] = await db.select({
-    activities: sql3`(select count(*) from ${agentActivities})::int`,
-    consultations: sql3`(select count(*) from ${consultations})::int`,
-    agentKeys: sql3`(select count(*) from ${agents})::int`,
-    agentsConnected: sql3`(select count(*) from ${agents} where last_seen_at is not null)::int`,
-    approved: sql3`(select count(*) from ${notes} where status = 'approved' and trigger is null)::int`,
-    sleeping: sql3`(select count(*) from ${notes} where status = 'approved' and trigger is not null)::int`,
-    pending: sql3`(select count(*) from ${notes} where status = 'proposed')::int`
-  }).from(sql3`(select 1) as one`);
+    activities: sql4`(select count(*) from ${agentActivities})::int`,
+    consultations: sql4`(select count(*) from ${consultations})::int`,
+    agentKeys: sql4`(select count(*) from ${agents})::int`,
+    agentsConnected: sql4`(select count(*) from ${agents} where last_seen_at is not null)::int`,
+    approved: sql4`(select count(*) from ${notes} where status = 'approved' and trigger is null)::int`,
+    sleeping: sql4`(select count(*) from ${notes} where status = 'approved' and trigger is not null)::int`,
+    pending: sql4`(select count(*) from ${notes} where status = 'proposed')::int`
+  }).from(sql4`(select 1) as one`);
   return {
     activities: row?.activities ?? 0,
     consultations: row?.consultations ?? 0,
@@ -2391,7 +2684,7 @@ function newId(prefix) {
   return `${prefix}_${randomBytes(9).toString("base64url")}`;
 }
 function hashKey(key) {
-  return createHash2("sha256").update(key).digest("hex");
+  return createHash3("sha256").update(key).digest("hex");
 }
 async function createAgent(db, input) {
   const apiKey = `panoma_${randomBytes(24).toString("base64url")}`;
@@ -2406,72 +2699,72 @@ async function createAgent(db, input) {
 }
 async function rotateAgentKey(db, input) {
   const kind = canonicalAgentKind(input.kind);
-  const [existing] = await db.select({ id: agents.id }).from(agents).where(inArray4(agents.kind, agentKindAliases(input.kind))).orderBy(desc3(agents.createdAt)).limit(1);
+  const [existing] = await db.select({ id: agents.id }).from(agents).where(inArray5(agents.kind, agentKindAliases(input.kind))).orderBy(desc4(agents.createdAt)).limit(1);
   if (!existing) return createAgent(db, { ...input, kind });
   const apiKey = `panoma_${randomBytes(24).toString("base64url")}`;
-  await db.update(agents).set({ name: input.name, kind, apiKeyHash: hashKey(apiKey) }).where(eq4(agents.id, existing.id));
+  await db.update(agents).set({ name: input.name, kind, apiKeyHash: hashKey(apiKey) }).where(eq5(agents.id, existing.id));
   return { id: existing.id, name: input.name, apiKey };
 }
 async function deleteAgent(db, id) {
-  const done = await db.delete(agents).where(eq4(agents.id, id)).returning({ id: agents.id });
+  const done = await db.delete(agents).where(eq5(agents.id, id)).returning({ id: agents.id });
   return done.length > 0;
 }
 async function authenticateAgent(db, apiKey) {
   if (!apiKey) return void 0;
-  const [agent] = await db.select().from(agents).where(eq4(agents.apiKeyHash, hashKey(apiKey))).limit(1);
+  const [agent] = await db.select().from(agents).where(eq5(agents.apiKeyHash, hashKey(apiKey))).limit(1);
   if (agent) {
-    await db.update(agents).set({ lastSeenAt: /* @__PURE__ */ new Date() }).where(eq4(agents.id, agent.id));
+    await db.update(agents).set({ lastSeenAt: /* @__PURE__ */ new Date() }).where(eq5(agents.id, agent.id));
   }
   return agent;
 }
 async function resolveProject(db, hint) {
   if (hint.slug) {
-    const [bySlug] = await db.select().from(projects).where(eq4(projects.slug, hint.slug)).limit(1);
+    const [bySlug] = await db.select().from(projects).where(eq5(projects.slug, hint.slug)).limit(1);
     if (bySlug) return bySlug;
   }
   if (hint.cwd) {
-    const [exact] = await db.select().from(projects).where(eq4(projects.root, hint.cwd)).limit(1);
+    const [exact] = await db.select().from(projects).where(eq5(projects.root, hint.cwd)).limit(1);
     if (exact) return exact;
-    const [ancestor] = await db.select().from(projects).where(sql4`${hint.cwd} like ${projects.root} || '/%'`).orderBy(sql4`length(root) desc`).limit(1);
+    const [ancestor] = await db.select().from(projects).where(sql5`${hint.cwd} like ${projects.root} || '/%'`).orderBy(sql5`length(root) desc`).limit(1);
     if (ancestor) return ancestor;
   }
   if (hint.remote) {
-    const normalized = hint.remote.replace(/\.git$/, "");
-    const [byRemote] = await db.select().from(projects).where(eq4(projects.gitRemoteUrl, normalized)).orderBy(sql4`last_commit_at desc nulls last`).limit(1);
+    const normalized2 = hint.remote.replace(/\.git$/, "");
+    const [byRemote] = await db.select().from(projects).where(eq5(projects.gitRemoteUrl, normalized2)).orderBy(sql5`last_commit_at desc nulls last`).limit(1);
     if (byRemote) return byRemote;
   }
   return void 0;
 }
 var TASK_TRANSPORT_LIMIT = 200;
 async function getAgentContext(db, projectId) {
-  const [project] = await db.select().from(projects).where(eq4(projects.id, projectId)).limit(1);
+  const [project] = await db.select().from(projects).where(eq5(projects.id, projectId)).limit(1);
   if (!project) return void 0;
   const [stack, deps, security, openTasks, [taskCount], recentWork, notes2, usage] = await Promise.all([
     db.select({
       name: technologies.name,
       kind: technologies.kind,
       version: projectTechnologies.version
-    }).from(projectTechnologies).innerJoin(technologies, eq4(technologies.id, projectTechnologies.technologyId)).where(eq4(projectTechnologies.projectId, projectId)).orderBy(desc3(projectTechnologies.confidence), asc3(technologies.name)),
+    }).from(projectTechnologies).innerJoin(technologies, eq5(technologies.id, projectTechnologies.technologyId)).where(eq5(projectTechnologies.projectId, projectId)).orderBy(desc4(projectTechnologies.confidence), asc4(technologies.name)),
     db.select({
       name: packages.name,
       ecosystem: packages.ecosystem,
       current: projectDependencies.resolvedVersion,
       latest: packages.latestVersion,
       isDev: projectDependencies.isDev
-    }).from(projectDependencies).innerJoin(packages, eq4(packages.id, projectDependencies.packageId)).where(eq4(projectDependencies.projectId, projectId)),
+    }).from(projectDependencies).innerJoin(packages, eq5(packages.id, projectDependencies.packageId)).where(eq5(projectDependencies.projectId, projectId)),
     db.select({
       advisoryId: advisories.id,
       severity: advisories.severity,
       packageName: packages.name,
       summary: advisories.summary,
       fixedVersions: advisories.fixedVersions
-    }).from(projectDependencies).innerJoin(packages, eq4(packages.id, projectDependencies.packageId)).innerJoin(
+    }).from(projectDependencies).innerJoin(packages, eq5(packages.id, projectDependencies.packageId)).innerJoin(
       vulnerabilities,
-      and4(
-        eq4(vulnerabilities.packageId, projectDependencies.packageId),
-        eq4(vulnerabilities.version, projectDependencies.resolvedVersion)
+      and5(
+        eq5(vulnerabilities.packageId, projectDependencies.packageId),
+        eq5(vulnerabilities.version, projectDependencies.resolvedVersion)
       )
-    ).innerJoin(advisories, eq4(advisories.id, vulnerabilities.advisoryId)).where(eq4(projectDependencies.projectId, projectId)),
+    ).innerJoin(advisories, eq5(advisories.id, vulnerabilities.advisoryId)).where(eq5(projectDependencies.projectId, projectId)),
     /*
       With a cap, and with a tiebreaker that does not depend on the scheduler.
       Without `limit`, a project with a thousand open tasks would send all thousand through HTTP
@@ -2479,17 +2772,17 @@ async function getAgentContext(db, projectId) {
       ties —two tasks created in the same millisecond, which is normal when created by an agent in
       a loop— in the order Postgres feels like: two identical calls returned different texts.
      */
-    db.select({ id: tasks.id, title: tasks.title, body: tasks.body, status: tasks.status }).from(tasks).where(and4(eq4(tasks.projectId, projectId), inArray4(tasks.status, ["open", "in-progress"]))).orderBy(desc3(tasks.createdAt), asc3(tasks.id)).limit(TASK_TRANSPORT_LIMIT),
+    db.select({ id: tasks.id, title: tasks.title, body: tasks.body, status: tasks.status }).from(tasks).where(and5(eq5(tasks.projectId, projectId), inArray5(tasks.status, ["open", "in-progress"]))).orderBy(desc4(tasks.createdAt), asc4(tasks.id)).limit(TASK_TRANSPORT_LIMIT),
     // The total truth, in order to be able to say '...and N more' without making it up.
-    db.select({ n: sql4`count(*)::int` }).from(tasks).where(
-      and4(eq4(tasks.projectId, projectId), inArray4(tasks.status, ["open", "in-progress"]))
+    db.select({ n: sql5`count(*)::int` }).from(tasks).where(
+      and5(eq5(tasks.projectId, projectId), inArray5(tasks.status, ["open", "in-progress"]))
     ),
     db.select({
       agent: agents.name,
       kind: agentActivities.kind,
       summary: agentActivities.summary,
       at: agentActivities.createdAt
-    }).from(agentActivities).innerJoin(agents, eq4(agents.id, agentActivities.agentId)).where(eq4(agentActivities.projectId, projectId)).orderBy(desc3(agentActivities.createdAt), asc3(agentActivities.id)).limit(15),
+    }).from(agentActivities).innerJoin(agents, eq5(agents.id, agentActivities.agentId)).where(eq5(agentActivities.projectId, projectId)).orderBy(desc4(agentActivities.createdAt), asc4(agentActivities.id)).limit(15),
     // Only the awake travel alone: the asleep serve themselves on their route, not here.
     listProjectNotes(db, projectId).then((all) => all.filter((note) => note.trigger === null)),
     noteUsage(db, projectId)
@@ -2528,12 +2821,12 @@ async function getAgentContext(db, projectId) {
 }
 async function openSession(db, agentId, projectId) {
   const [existing] = await db.select({ id: agentSessions.id }).from(agentSessions).where(
-    and4(
-      eq4(agentSessions.agentId, agentId),
-      eq4(agentSessions.projectId, projectId),
-      sql4`ended_at is null`
+    and5(
+      eq5(agentSessions.agentId, agentId),
+      eq5(agentSessions.projectId, projectId),
+      sql5`ended_at is null`
     )
-  ).orderBy(desc3(agentSessions.startedAt)).limit(1);
+  ).orderBy(desc4(agentSessions.startedAt)).limit(1);
   if (existing) return existing.id;
   const id = newId("ses");
   await db.insert(agentSessions).values({ id, agentId, projectId });
@@ -2567,7 +2860,7 @@ async function logActivity(db, input) {
   return { id };
 }
 async function closeSession(db, sessionId, summary) {
-  await db.update(agentSessions).set({ endedAt: /* @__PURE__ */ new Date(), summary }).where(eq4(agentSessions.id, sessionId));
+  await db.update(agentSessions).set({ endedAt: /* @__PURE__ */ new Date(), summary }).where(eq5(agentSessions.id, sessionId));
 }
 async function createTask(db, input) {
   const id = newId("tsk");
@@ -2585,7 +2878,7 @@ async function createTask(db, input) {
   return id;
 }
 async function discardTask(db, taskId) {
-  const updated = await db.update(tasks).set({ status: "discarded" }).where(and4(eq4(tasks.id, taskId), inArray4(tasks.status, ["open", "in-progress"]))).returning({ id: tasks.id });
+  const updated = await db.update(tasks).set({ status: "discarded" }).where(and5(eq5(tasks.id, taskId), inArray5(tasks.status, ["open", "in-progress"]))).returning({ id: tasks.id });
   return updated.length > 0;
 }
 async function listProjectLaunches(db, projectId) {
@@ -2596,14 +2889,14 @@ async function listProjectLaunches(db, projectId) {
     kind: launches.kind,
     taskId: launches.taskId,
     taskTitle: tasks.title
-  }).from(launches).leftJoin(tasks, eq4(tasks.id, launches.taskId)).where(eq4(launches.projectId, projectId)).orderBy(desc3(launches.at)).limit(50);
+  }).from(launches).leftJoin(tasks, eq5(tasks.id, launches.taskId)).where(eq5(launches.projectId, projectId)).orderBy(desc4(launches.at)).limit(50);
 }
 async function discardedFindings(db) {
   const rows = await db.select({
     fromLook: tasks.fromLook,
     fromFinding: tasks.fromFinding,
     status: tasks.status
-  }).from(tasks).where(and4(isNotNull2(tasks.fromLook), isNotNull2(tasks.fromFinding))).orderBy(desc3(tasks.createdAt), desc3(tasks.id));
+  }).from(tasks).where(and5(isNotNull2(tasks.fromLook), isNotNull2(tasks.fromFinding))).orderBy(desc4(tasks.createdAt), desc4(tasks.id));
   return ultimaPalabra(
     rows.map((row) => ({
       key: row.fromLook !== null && row.fromFinding !== null ? `${row.fromLook} ${row.fromFinding}` : null,
@@ -2630,7 +2923,7 @@ async function getTask(db, id) {
     projectId: tasks.projectId,
     projectSlug: projects.slug,
     projectRoot: projects.root
-  }).from(tasks).innerJoin(projects, eq4(projects.id, tasks.projectId)).where(eq4(tasks.id, id)).limit(1);
+  }).from(tasks).innerJoin(projects, eq5(projects.id, tasks.projectId)).where(eq5(tasks.id, id)).limit(1);
   return row;
 }
 async function assignedFindings(db) {
@@ -2639,9 +2932,9 @@ async function assignedFindings(db) {
     fromLook: tasks.fromLook,
     fromFinding: tasks.fromFinding
   }).from(tasks).where(
-    and4(
+    and5(
       isNotNull2(tasks.fromLook),
-      inArray4(tasks.status, ["open", "in-progress"])
+      inArray5(tasks.status, ["open", "in-progress"])
     )
   );
   const byFinding = /* @__PURE__ */ new Map();
@@ -2671,10 +2964,10 @@ async function launchedTasks(db) {
 }
 async function assignedCritiques(db, projectId) {
   const rows = await db.select({ id: tasks.id, key: tasks.fromCritique }).from(tasks).where(
-    and4(
-      eq4(tasks.projectId, projectId),
+    and5(
+      eq5(tasks.projectId, projectId),
       isNotNull2(tasks.fromCritique),
-      inArray4(tasks.status, ["open", "in-progress"])
+      inArray5(tasks.status, ["open", "in-progress"])
     )
   );
   const byKey = /* @__PURE__ */ new Map();
@@ -2682,19 +2975,19 @@ async function assignedCritiques(db, projectId) {
   return byKey;
 }
 async function discardedCritiques(db, projectId) {
-  const rows = await db.select({ key: tasks.fromCritique, status: tasks.status }).from(tasks).where(and4(eq4(tasks.projectId, projectId), isNotNull2(tasks.fromCritique))).orderBy(desc3(tasks.createdAt), desc3(tasks.id));
+  const rows = await db.select({ key: tasks.fromCritique, status: tasks.status }).from(tasks).where(and5(eq5(tasks.projectId, projectId), isNotNull2(tasks.fromCritique))).orderBy(desc4(tasks.createdAt), desc4(tasks.id));
   return ultimaPalabra(rows);
 }
 async function claimTask(db, taskId, agentId) {
-  const updated = await db.update(tasks).set({ status: "in-progress", assignedAgentId: agentId, claimedAt: /* @__PURE__ */ new Date() }).where(and4(eq4(tasks.id, taskId), eq4(tasks.status, "open"))).returning({ id: tasks.id });
+  const updated = await db.update(tasks).set({ status: "in-progress", assignedAgentId: agentId, claimedAt: /* @__PURE__ */ new Date() }).where(and5(eq5(tasks.id, taskId), eq5(tasks.status, "open"))).returning({ id: tasks.id });
   return updated.length > 0;
 }
 async function completeTask(db, taskId, agentId, result) {
   const updated = await db.update(tasks).set({ status: "done", completedAt: /* @__PURE__ */ new Date(), result }).where(
-    and4(
-      eq4(tasks.id, taskId),
-      inArray4(tasks.status, ["open", "in-progress"]),
-      or3(eq4(tasks.assignedAgentId, agentId), sql4`assigned_agent_id is null`)
+    and5(
+      eq5(tasks.id, taskId),
+      inArray5(tasks.status, ["open", "in-progress"]),
+      or3(eq5(tasks.assignedAgentId, agentId), sql5`assigned_agent_id is null`)
     )
   ).returning({ id: tasks.id });
   return updated.length > 0;
@@ -2710,35 +3003,91 @@ async function listProjectActivity(db, projectId) {
     agentName: agents.name,
     agentKind: agents.kind,
     sessionId: agentActivities.sessionId
-  }).from(agentActivities).innerJoin(agents, eq4(agents.id, agentActivities.agentId)).where(eq4(agentActivities.projectId, projectId)).orderBy(desc3(agentActivities.createdAt)).limit(100);
-}
-async function listSessionActivities(db, sessionId) {
-  return db.select({
+  }).from(agentActivities).innerJoin(agents, eq5(agents.id, agentActivities.agentId)).where(eq5(agentActivities.projectId, projectId)).orderBy(desc4(agentActivities.createdAt)).limit(100);
+}
+var JOURNAL_PAGE_SIZE = 12;
+var JOURNAL_ENTRY_CHARS = 4e3;
+var MATCH_START = "[[[panoma-match]]]";
+var MATCH_END = "[[[/panoma-match]]]";
+function boundedHeadline(headline) {
+  const first = headline.indexOf(MATCH_START);
+  const plain = headline.replaceAll(MATCH_START, "").replaceAll(MATCH_END, "");
+  if (plain.length <= 1200) return plain;
+  const start = Math.max(0, first - 100);
+  const end = Math.min(plain.length, start + 1200);
+  return `${start > 0 ? "\u2026" : ""}${plain.slice(start, end)}${end < plain.length ? "\u2026" : ""}`;
+}
+async function journalMatches(db, projectId, query, limit, position) {
+  const rows = await db.select({
+    id: agentActivities.id,
+    agent: agents.name,
     kind: agentActivities.kind,
     summary: agentActivities.summary,
     details: agentActivities.details,
-    /* The site of the accident: the distiller gets the proposal's 'where' from this field. */
-    filesTouched: agentActivities.filesTouched
-  }).from(agentActivities).where(eq4(agentActivities.sessionId, sessionId)).orderBy(asc3(agentActivities.createdAt), asc3(agentActivities.id)).limit(50);
+    at: agentActivities.createdAt,
+    positionAt: sql5`to_char(${agentActivities.createdAt} at time zone 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.US"Z"')`,
+    headline: sql5`ts_headline('simple',
+        replace(replace(${agentActivities.summary} || E'\n\n' || coalesce(${agentActivities.details}, ''), ${MATCH_START}, ''), ${MATCH_END}, ''),
+        websearch_to_tsquery('simple', ${query}),
+        'StartSel=[[[panoma-match]]],StopSel=[[[/panoma-match]]],MaxWords=50,MinWords=15,MaxFragments=1')`
+  }).from(agentActivities).innerJoin(agents, eq5(agents.id, agentActivities.agentId)).where(and5(
+    eq5(agentActivities.projectId, projectId),
+    sql5`to_tsvector('simple', ${agentActivities.summary} || ' ' || coalesce(${agentActivities.details}, '')) @@ websearch_to_tsquery('simple', ${query})`,
+    position === void 0 ? void 0 : sql5`(${agentActivities.createdAt} < ${position.at}::timestamptz or (${agentActivities.createdAt} = ${position.at}::timestamptz and ${agentActivities.id} > ${position.id}))`
+  )).orderBy(desc4(agentActivities.createdAt), asc4(agentActivities.id)).limit(limit);
+  return rows.map(({ headline, ...row }) => ({ ...row, excerpt: boundedHeadline(headline) }));
 }
 async function searchJournal(db, projectId, query, limit = 12) {
   const clean = query.trim();
   if (clean === "") return [];
-  return db.select({
+  return journalMatches(db, projectId, clean, limit);
+}
+async function searchJournalPage(db, projectId, query, cursor) {
+  const clean = query.trim();
+  let position;
+  if (cursor !== void 0) {
+    try {
+      if (cursor.length > 4096 || !/^[A-Za-z0-9_-]+$/.test(cursor)) throw new Error();
+      const saved = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+      if (saved["projectId"] !== projectId || saved["query"] !== clean || typeof saved["at"] !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}Z$/.test(saved["at"]) || !Number.isFinite(Date.parse(saved["at"])) || typeof saved["id"] !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(saved["id"])) throw new Error();
+      position = { at: saved["at"], id: saved["id"] };
+    } catch {
+      throw new RangeError("Invalid journal cursor. Repeat the search without a cursor.");
+    }
+  }
+  if (clean === "") return { matches: [], nextCursor: null };
+  const rows = await journalMatches(db, projectId, clean, JOURNAL_PAGE_SIZE + 1, position);
+  const page = rows.slice(0, JOURNAL_PAGE_SIZE);
+  const last = page.at(-1);
+  const nextCursor = rows.length > JOURNAL_PAGE_SIZE && last ? Buffer.from(JSON.stringify({
+    projectId,
+    query: clean,
+    at: last.positionAt,
+    id: last.id
+  })).toString("base64url") : null;
+  return { matches: page, nextCursor };
+}
+async function readJournalEntry(db, projectId, entryId, offset = 0) {
+  if (!Number.isSafeInteger(offset) || offset < 0) throw new RangeError("Journal offset must be a non-negative integer.");
+  const [entry] = await db.select({
+    id: agentActivities.id,
     agent: agents.name,
     kind: agentActivities.kind,
     summary: agentActivities.summary,
     details: agentActivities.details,
     at: agentActivities.createdAt
-  }).from(agentActivities).innerJoin(agents, eq4(agents.id, agentActivities.agentId)).where(
-    and4(
-      eq4(agentActivities.projectId, projectId),
-      sql4`to_tsvector('simple', ${agentActivities.summary} || ' ' || coalesce(${agentActivities.details}, '')) @@ websearch_to_tsquery('simple', ${clean})`
-    )
-  ).orderBy(desc3(agentActivities.createdAt), asc3(agentActivities.id)).limit(limit);
+  }).from(agentActivities).innerJoin(agents, eq5(agents.id, agentActivities.agentId)).where(and5(eq5(agentActivities.projectId, projectId), eq5(agentActivities.id, entryId))).limit(1);
+  if (!entry) return void 0;
+  const original = `${entry.summary}${entry.details ? `
+
+${entry.details}` : ""}`;
+  if (offset > original.length) throw new RangeError("Journal offset is past the end of this entry.");
+  const end = Math.min(original.length, offset + JOURNAL_ENTRY_CHARS);
+  const { details: _details, ...metadata } = entry;
+  return { ...metadata, text: original.slice(offset, end), offset, totalChars: original.length, nextOffset: end < original.length ? end : null };
 }
 async function listProjectTasks(db, projectId, statuses) {
-  const suyas = eq4(tasks.projectId, projectId);
+  const suyas = eq5(tasks.projectId, projectId);
   return db.select({
     id: tasks.id,
     title: tasks.title,
@@ -2748,7 +3097,7 @@ async function listProjectTasks(db, projectId, statuses) {
     createdBy: tasks.createdBy,
     createdAt: tasks.createdAt,
     agentName: agents.name
-  }).from(tasks).leftJoin(agents, eq4(agents.id, tasks.assignedAgentId)).where(statuses === void 0 ? suyas : and4(suyas, inArray4(tasks.status, statuses))).orderBy(desc3(tasks.createdAt));
+  }).from(tasks).leftJoin(agents, eq5(agents.id, tasks.assignedAgentId)).where(statuses === void 0 ? suyas : and5(suyas, inArray5(tasks.status, statuses))).orderBy(desc4(tasks.createdAt));
 }
 async function listAllActivity(db, limit = 200) {
   return db.select({
@@ -2759,7 +3108,7 @@ async function listAllActivity(db, limit = 200) {
     agentName: agents.name,
     projectName: projects.name,
     projectSlug: projects.slug
-  }).from(agentActivities).innerJoin(agents, eq4(agents.id, agentActivities.agentId)).innerJoin(projects, eq4(projects.id, agentActivities.projectId)).orderBy(desc3(agentActivities.createdAt)).limit(limit);
+  }).from(agentActivities).innerJoin(agents, eq5(agents.id, agentActivities.agentId)).innerJoin(projects, eq5(projects.id, agentActivities.projectId)).orderBy(desc4(agentActivities.createdAt)).limit(limit);
 }
 async function listAgents(db) {
   return db.select({
@@ -2768,40 +3117,28 @@ async function listAgents(db) {
     kind: agents.kind,
     createdAt: agents.createdAt,
     lastSeenAt: agents.lastSeenAt,
-    activities: sql4`(
+    activities: sql5`(
         select count(*)::int from agent_activities aa where aa.agent_id = agents.id
       )`,
-    projects: sql4`(
+    projects: sql5`(
         select count(distinct aa.project_id)::int from agent_activities aa
         where aa.agent_id = agents.id
       )`
-  }).from(agents).orderBy(desc3(agents.lastSeenAt));
+  }).from(agents).orderBy(desc4(agents.lastSeenAt));
 }
 
 // src/consultations.ts
-import { and as and5, asc as asc4, desc as desc4, eq as eq5, isNull as isNull2, or as or4, sql as sql5 } from "drizzle-orm";
+import { and as and6, asc as asc5, desc as desc5, eq as eq6, isNull as isNull2, or as or4, sql as sql6 } from "drizzle-orm";
 import { redactSecrets as redactSecrets3 } from "@panoma/core";
 var CONSULT_MAX = 300;
 var CONSULT_PENDING_MAX = 20;
+var STALE_MAX_DAYS = 30;
 async function recordConsultation(db, input) {
   const question = redactSecrets3(input.question.trim());
   if (question.length === 0 || question.length > CONSULT_MAX) {
     return { refused: "tooLong", max: CONSULT_MAX };
   }
-  const [row] = await db.select({ pending: sql5`count(*)::int` }).from(consultations).where(
-    and5(
-      eq5(consultations.projectId, input.projectId),
-      isNull2(consultations.verdict),
-      or4(
-        eq5(consultations.status, "drafted"),
-        and5(
-          eq5(consultations.status, "drafting"),
-          sql5`${consultations.createdAt} > now() - interval '24 hours'`
-        )
-      )
-    )
-  );
-  const pending = row?.pending ?? 0;
+  const pending = await pendingConsultations(db, input.projectId);
   if (pending >= CONSULT_PENDING_MAX) return { refused: "queueFull", max: CONSULT_PENDING_MAX };
   const id = newId("ask");
   await db.insert(consultations).values({
@@ -2812,30 +3149,53 @@ async function recordConsultation(db, input) {
   });
   return { id, pending: pending + 1 };
 }
+async function pendingConsultations(db, projectId) {
+  const [row] = await db.select({ pending: sql6`count(*)::int` }).from(consultations).where(
+    and6(
+      eq6(consultations.projectId, projectId),
+      isNull2(consultations.verdict),
+      or4(
+        eq6(consultations.status, "drafted"),
+        and6(
+          eq6(consultations.status, "drafting"),
+          sql6`${consultations.createdAt} > now() - interval '24 hours'`
+        )
+      )
+    )
+  );
+  return row?.pending ?? 0;
+}
 async function draftConsultation(db, id, draft) {
   const fields = "abstained" in draft ? { status: "abstained", draftedAt: /* @__PURE__ */ new Date() } : { status: "drafted", answer: draft.answer, beliefIds: draft.beliefIds, draftedAt: /* @__PURE__ */ new Date() };
-  const moved = await db.update(consultations).set(fields).where(and5(eq5(consultations.id, id), eq5(consultations.status, "drafting"))).returning({ id: consultations.id });
+  const moved = await db.update(consultations).set(fields).where(and6(eq6(consultations.id, id), eq6(consultations.status, "drafting"))).returning({ id: consultations.id });
   return moved.length > 0;
 }
-async function labelConsultation(db, id, verdict) {
+async function labelConsultation(db, id, verdict, projectId) {
   const moved = await db.update(consultations).set({ verdict, verdictAt: /* @__PURE__ */ new Date() }).where(
-    and5(
-      eq5(consultations.id, id),
-      eq5(consultations.status, "drafted"),
-      isNull2(consultations.verdict)
+    and6(
+      eq6(consultations.id, id),
+      eq6(consultations.status, "drafted"),
+      isNull2(consultations.verdict),
+      ...projectId === void 0 ? [] : [eq6(consultations.projectId, projectId)]
     )
   ).returning({ id: consultations.id });
   return moved.length > 0;
 }
-async function staleDrafting(db, projectId, olderThanMs = 10 * 6e4, limit = 5) {
+async function draftingConsultation(db, id) {
+  const [row] = await db.select({ question: consultations.question }).from(consultations).where(and6(eq6(consultations.id, id), eq6(consultations.status, "drafting"))).limit(1);
+  return row;
+}
+async function staleDrafting(db, projectId, olderThanMs = 10 * 6e4, limit = 5, withinMs = STALE_MAX_DAYS * 864e5) {
   const cutoff = new Date(Date.now() - olderThanMs);
+  const since = new Date(Date.now() - withinMs);
   return db.select({ id: consultations.id, question: consultations.question }).from(consultations).where(
-    and5(
-      eq5(consultations.projectId, projectId),
-      eq5(consultations.status, "drafting"),
-      sql5`${consultations.createdAt} < ${cutoff}`
+    and6(
+      eq6(consultations.projectId, projectId),
+      eq6(consultations.status, "drafting"),
+      sql6`${consultations.createdAt} < ${cutoff}`,
+      sql6`${consultations.createdAt} >= ${since}`
     )
-  ).orderBy(asc4(consultations.createdAt)).limit(limit);
+  ).orderBy(asc5(consultations.createdAt)).limit(limit);
 }
 async function listProjectConsultations(db, projectId, limit = 20) {
   const rows = await db.select({
@@ -2847,19 +3207,19 @@ async function listProjectConsultations(db, projectId, limit = 20) {
     verdict: consultations.verdict,
     agent: agents.name,
     createdAt: consultations.createdAt
-  }).from(consultations).innerJoin(agents, eq5(agents.id, consultations.agentId)).where(eq5(consultations.projectId, projectId)).orderBy(desc4(consultations.createdAt), asc4(consultations.id)).limit(limit);
+  }).from(consultations).innerJoin(agents, eq6(agents.id, consultations.agentId)).where(eq6(consultations.projectId, projectId)).orderBy(desc5(consultations.createdAt), asc5(consultations.id)).limit(limit);
   return rows.map((row) => ({ ...row, beliefIds: row.beliefIds ?? [] }));
 }
-async function doubleReport(db, days = 30) {
+async function doubleReport(db, days = STALE_MAX_DAYS) {
   const since = new Date(Date.now() - days * 864e5);
   const [row] = await db.select({
-    questions: sql5`count(*)::int`,
-    drafted: sql5`count(*) filter (where ${consultations.status} = 'drafted')::int`,
-    abstained: sql5`count(*) filter (where ${consultations.status} = 'abstained')::int`,
-    labeled: sql5`count(*) filter (where ${consultations.verdict} is not null)::int`,
-    backed: sql5`count(*) filter (where ${consultations.verdict} = 'backed')::int`,
-    vetoed: sql5`count(*) filter (where ${consultations.verdict} = 'vetoed')::int`
-  }).from(consultations).where(sql5`${consultations.createdAt} >= ${since}`);
+    questions: sql6`count(*)::int`,
+    drafted: sql6`count(*) filter (where ${consultations.status} = 'drafted')::int`,
+    abstained: sql6`count(*) filter (where ${consultations.status} = 'abstained')::int`,
+    labeled: sql6`count(*) filter (where ${consultations.verdict} is not null)::int`,
+    backed: sql6`count(*) filter (where ${consultations.verdict} = 'backed')::int`,
+    vetoed: sql6`count(*) filter (where ${consultations.verdict} = 'vetoed')::int`
+  }).from(consultations).where(sql6`${consultations.createdAt} >= ${since}`);
   const drafted = row?.drafted ?? 0;
   const abstained = row?.abstained ?? 0;
   const labeled = row?.labeled ?? 0;
@@ -2877,8 +3237,611 @@ async function doubleReport(db, days = 30) {
   };
 }
 
+// src/episodes.ts
+import { redactSecrets as redactSecrets4 } from "@panoma/core";
+import { and as and7, asc as asc6, desc as desc6, eq as eq7, getTableColumns, inArray as inArray6, isNull as isNull3, sql as sql7 } from "drizzle-orm";
+var EPISODE_FIELDS = [
+  "context",
+  "goal",
+  "constraints",
+  "alternatives",
+  "decision",
+  "rationale",
+  "outcome",
+  "conditions",
+  "exceptions"
+];
+var CHUNK = 500;
+var DecisionEpisodeConflict = class extends Error {
+  constructor(code) {
+    super(code === "stale" ? "The decision episode changed since it was read." : "Another version of this decision is active.");
+    this.code = code;
+    this.name = "DecisionEpisodeConflict";
+  }
+  code;
+};
+async function episodeWrite(db, work) {
+  return db.transaction(async (tx) => {
+    await tx.execute(sql7`lock table ${decisionEpisodes} in share row exclusive mode`);
+    return work(tx);
+  });
+}
+async function saveNarratives(db, rows) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const clean = { ...row, text: redactSecrets4(row.text.trim()), context: row.context === null ? null : redactSecrets4(row.context) };
+    if (!clean.text || !clean.identity || !clean.source || !clean.sessionId || !Number.isFinite(clean.at.getTime())) {
+      throw new Error("Narratives require human text, a project identity, a source, a session and a valid date.");
+    }
+    const id = idFor(JSON.stringify([clean.source, clean.sessionId, clean.at.toISOString(), clean.text]));
+    unique.set(id, clean);
+  }
+  const values = [...unique].map(([id, row]) => ({ id, ...row }));
+  let inserted = 0;
+  for (let offset = 0; offset < values.length; offset += CHUNK) {
+    const chunk = values.slice(offset, offset + CHUNK);
+    const saved = await db.insert(narratives).values(chunk).onConflictDoNothing().returning({ id: narratives.id });
+    inserted += saved.length;
+    const insertedIds = new Set(saved.map((row) => row.id));
+    const existing = chunk.filter((row) => !insertedIds.has(row.id));
+    if (existing.length === 0) continue;
+    const stored = await narrativesByIds(db, existing.map((row) => row.id));
+    const identities = new Map(stored.map((row) => [row.id, row.identity]));
+    const remaps = /* @__PURE__ */ new Map();
+    for (const row of existing) {
+      if (identities.get(row.id) === row.identity) continue;
+      const ids = remaps.get(row.identity) ?? [];
+      ids.push(row.id);
+      remaps.set(row.identity, ids);
+    }
+    for (const [identity, ids] of remaps) {
+      await db.update(narratives).set({ identity, readAt: null }).where(inArray6(narratives.id, ids));
+    }
+  }
+  return { inserted };
+}
+async function listNarratives(db, options = {}) {
+  const query = db.select().from(narratives).where(and7(
+    options.identity === void 0 ? void 0 : eq7(narratives.identity, options.identity),
+    options.unread ? isNull3(narratives.readAt) : void 0
+  )).orderBy(
+    ...options.unread ? [sql7`${narratives.failedAt} asc nulls first`] : [],
+    desc6(narratives.at),
+    asc6(narratives.id)
+  );
+  return options.limit === void 0 ? query : query.limit(options.limit);
+}
+async function narrativesByIds(db, ids) {
+  const unique = [...new Set(ids)];
+  const rows = [];
+  for (let offset = 0; offset < unique.length; offset += CHUNK) {
+    rows.push(...await db.select().from(narratives).where(inArray6(narratives.id, unique.slice(offset, offset + CHUNK))));
+  }
+  return rows.sort((a, b) => b.at.getTime() - a.at.getTime() || a.id.localeCompare(b.id));
+}
+async function narrativeCount(db) {
+  const [row] = await db.select({
+    total: sql7`count(*)::int`,
+    pending: sql7`count(*) filter (where ${narratives.readAt} is null)::int`,
+    deferred: sql7`count(*) filter (where ${narratives.readAt} is null and ${narratives.failedAt} is not null)::int`
+  }).from(narratives);
+  return row ?? { total: 0, pending: 0, deferred: 0 };
+}
+async function markNarrativesFailed(db, ids) {
+  let marked = 0;
+  const unique = [...new Set(ids)];
+  for (let offset = 0; offset < unique.length; offset += CHUNK) {
+    const rows = await db.update(narratives).set({ failedAt: /* @__PURE__ */ new Date() }).where(and7(
+      inArray6(narratives.id, unique.slice(offset, offset + CHUNK)),
+      isNull3(narratives.readAt)
+    )).returning({ id: narratives.id });
+    marked += rows.length;
+  }
+  return marked;
+}
+async function deleteNarratives(db, options = {}) {
+  const episodes = await db.delete(decisionEpisodes).where(and7(
+    eq7(decisionEpisodes.origin, "history"),
+    options.source === void 0 ? void 0 : sql7`exists (
+      select 1 from jsonb_each(${decisionEpisodes.fields}) as field(name, evidence)
+      inner join ${narratives} on ${narratives.id} = field.evidence->>'narrativeId'
+      where ${narratives.source} = ${options.source}
+    )`
+  )).returning({ id: decisionEpisodes.id });
+  const narratives2 = await db.delete(narratives).where(
+    options.source === void 0 ? void 0 : eq7(narratives.source, options.source)
+  ).returning({ id: narratives.id });
+  return { narratives: narratives2.length, episodes: episodes.length };
+}
+async function markNarrativesRead(db, ids, expectedIdentity) {
+  let marked = 0;
+  const unique = [...new Set(ids)];
+  for (let offset = 0; offset < unique.length; offset += CHUNK) {
+    const rows = await db.update(narratives).set({ readAt: /* @__PURE__ */ new Date() }).where(and7(
+      inArray6(narratives.id, unique.slice(offset, offset + CHUNK)),
+      isNull3(narratives.readAt),
+      expectedIdentity === void 0 ? void 0 : eq7(narratives.identity, expectedIdentity)
+    )).returning({ id: narratives.id });
+    marked += rows.length;
+  }
+  return marked;
+}
+function cleanFields(input) {
+  const fields = {};
+  for (const name of Object.keys(input.fields)) {
+    if (!EPISODE_FIELDS.includes(name)) throw new Error("Unknown decision episode field.");
+  }
+  for (const name of EPISODE_FIELDS) {
+    const field = input.fields[name];
+    if (!field) continue;
+    const text = redactSecrets4(field.text.trim());
+    if (!text) throw new Error("Decision episode fields must contain text.");
+    if (input.origin === "owner" && field.narrativeId !== void 0) {
+      throw new Error("Owner-authored episodes cannot claim extracted narrative evidence.");
+    }
+    if (input.origin === "history" && !field.narrativeId) {
+      throw new Error("Every extracted field must cite its human narrative.");
+    }
+    fields[name] = field.narrativeId ? { text, narrativeId: field.narrativeId } : { text };
+  }
+  if (Object.keys(fields).length === 0) throw new Error("A decision episode must contain at least one field.");
+  return fields;
+}
+function normalized(text) {
+  return text.normalize("NFC").replace(/\s+/g, " ").trim().toLowerCase();
+}
+function episodeId(row) {
+  const fields = EPISODE_FIELDS.flatMap((name) => {
+    const field = row.fields[name];
+    return field ? [[name, row.origin === "owner" ? normalized(field.text) : field.text, field.narrativeId ?? null]] : [];
+  });
+  return idFor(JSON.stringify([row.origin, row.origin === "owner" ? row.identity : null, row.supersedesId ?? null, fields]));
+}
+async function saveDecisionEpisodes(db, rows, options = {}) {
+  if (rows.length === 0) return [];
+  return episodeWrite(db, (tx) => saveEpisodesLocked(tx, rows, options));
+}
+async function saveEpisodesLocked(db, rows, options) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const input of rows) {
+    if (input.origin !== "owner" && input.origin !== "history") throw new Error("Unknown decision episode origin.");
+    if (input.origin === "owner" && input.model !== null) throw new Error("Owner-authored episodes cannot have a model attribution.");
+    if (input.origin === "history" && (!input.identity || !input.model?.trim())) {
+      throw new Error("Extracted episodes require a project identity and a model attribution.");
+    }
+    if (input.validUntil !== void 0 && input.validUntil !== null && !Number.isFinite(input.validUntil.getTime())) {
+      throw new Error("A decision episode expiry must be a valid instant.");
+    }
+    if (input.supersedesId !== void 0 && input.supersedesId !== null) {
+      if (input.origin !== "owner") throw new Error("Only an owner-authored episode can revise a previous decision.");
+      const previous = await decisionEpisodeById(db, input.supersedesId);
+      if (!previous || previous.identity !== input.identity) throw new Error("A revision must reference an existing episode in the same project scope.");
+    }
+    const row = { ...input, fields: cleanFields(input) };
+    unique.set(episodeId(row), row);
+  }
+  const narrativeIds = [...unique.values()].flatMap((row) => Object.values(row.fields).flatMap((field) => field.narrativeId ? [field.narrativeId] : []));
+  const evidence = new Map((await narrativesByIds(db, narrativeIds)).map((row) => [row.id, row]));
+  for (const row of unique.values()) {
+    if (row.origin !== "history") continue;
+    for (const field of Object.values(row.fields)) {
+      const narrative = evidence.get(field.narrativeId);
+      if (!narrative || narrative.identity !== row.identity || !narrative.text.includes(field.text)) {
+        throw new Error("Extracted fields must quote an existing human narrative from the same project.");
+      }
+    }
+  }
+  const saved = [];
+  for (const [id, row] of unique) {
+    const existing = await decisionEpisodeById(db, id);
+    if (existing) {
+      saved.push(existing);
+      continue;
+    }
+    if (row.supersedesId) {
+      const previous = await decisionEpisodeById(db, row.supersedesId);
+      if (options.expectedPreviousUpdatedAt && previous?.updatedAt.getTime() !== options.expectedPreviousUpdatedAt.getTime()) {
+        throw new DecisionEpisodeConflict("stale");
+      }
+      if (await activeSuccessor(db, row.supersedesId)) throw new DecisionEpisodeConflict("activeSuccessor");
+    }
+    const [inserted] = await db.insert(decisionEpisodes).values({ id, ...row }).onConflictDoNothing().returning();
+    if (inserted) {
+      if (row.supersedesId) {
+        await db.update(decisionEpisodes).set({ status: "dismissed", updatedAt: sql7`greatest(current_timestamp, ${decisionEpisodes.updatedAt} + interval '1 millisecond')` }).where(eq7(decisionEpisodes.id, row.supersedesId));
+      }
+      saved.push(asEpisode(inserted));
+      continue;
+    }
+    if (row.origin === "history") {
+      await db.update(decisionEpisodes).set({ identity: row.identity, updatedAt: /* @__PURE__ */ new Date() }).where(and7(
+        eq7(decisionEpisodes.id, id),
+        sql7`${decisionEpisodes.identity} is distinct from ${row.identity}`
+      ));
+    }
+    const replayed = await decisionEpisodeById(db, id);
+    if (replayed) saved.push(replayed);
+  }
+  return saved;
+}
+function asEpisode(row) {
+  return { ...row, fields: row.fields };
+}
+function validEvidence(columns = decisionEpisodes) {
+  return sql7`(${columns.origin} = 'owner' or not exists (
+    select 1 from jsonb_each(${columns.fields}) as field(name, evidence)
+    left join ${narratives} on ${narratives.id} = field.evidence->>'narrativeId'
+    where ${narratives.id} is null
+      or ${narratives.identity} is distinct from ${columns.identity}
+  ))`;
+}
+var CANDIDATE = { origin: sql7`candidate.origin`, fields: sql7`candidate.fields`, identity: sql7`candidate.identity` };
+function competingActive() {
+  return sql7`exists (
+    select 1 from decision_episodes candidate
+    where candidate.id in (${familyIds(sql7`decision_episodes.id`)})
+      and candidate.id <> decision_episodes.id and candidate.status = 'active'
+      and ${validEvidence(CANDIDATE)}
+  )`;
+}
+var CREATED_MS = sql7`date_trunc('milliseconds', ${decisionEpisodes.createdAt})`;
+var SEARCHED_FIELDS = ["goal", "decision", "rationale", "conditions", "exceptions", "context"];
+async function listDecisionEpisodes(db, options = {}) {
+  const needle = options.query?.trim() ?? "";
+  const pattern = `%${needle.replace(/[\\%_]/g, (char) => `\\${char}`)}%`;
+  const query = db.select().from(decisionEpisodes).where(and7(
+    validEvidence(),
+    options.identity === void 0 ? void 0 : options.identity === null ? isNull3(decisionEpisodes.identity) : eq7(decisionEpisodes.identity, options.identity),
+    options.status === void 0 ? void 0 : eq7(decisionEpisodes.status, options.status),
+    // Legacy conflicting families remain inspectable by the owner, but cannot supply authority.
+    options.unambiguousOnly ? sql7`not ${competingActive()}` : void 0,
+    // The stored instant is the boundary and not the last valid moment: reaching it is expiring.
+    // That is why a day is stored at 23:59:59.999 — the decision covers the whole of its last day.
+    options.activeAt === void 0 ? void 0 : sql7`(${decisionEpisodes.validUntil} is null
+      or ${decisionEpisodes.validUntil} > ${options.activeAt.toISOString()}::timestamptz)`,
+    options.ownerDecisionsOnly ? and7(
+      eq7(decisionEpisodes.origin, "owner"),
+      sql7`nullif(btrim(${decisionEpisodes.fields}->'decision'->>'text'), '') is not null`
+    ) : void 0,
+    needle === "" ? void 0 : sql7`concat_ws(' ', ${sql7.join(
+      SEARCHED_FIELDS.map((name) => sql7`coalesce(${decisionEpisodes.fields}->${sql7.raw(`'${name}'`)}->>'text', '')`),
+      sql7`, `
+    )}) ilike ${pattern} escape '\\'`,
+    options.before === void 0 ? void 0 : sql7`(${CREATED_MS} < ${options.before.createdAt.toISOString()}::timestamptz
+      or (${CREATED_MS} = ${options.before.createdAt.toISOString()}::timestamptz and ${decisionEpisodes.id} > ${options.before.id}))`
+  )).orderBy(sql7`${CREATED_MS} desc`, asc6(decisionEpisodes.id));
+  const rows = await (options.limit === void 0 ? query : query.limit(options.limit));
+  return rows.map(asEpisode);
+}
+async function listConflictingEpisodeFamilies(db) {
+  const rows = await db.select({
+    ...getTableColumns(decisionEpisodes),
+    members: sql7`(
+      select string_agg(candidate.id, ',' order by candidate.created_at desc, candidate.id asc)
+      from decision_episodes candidate
+      where candidate.id in (${familyIds(sql7`decision_episodes.id`)})
+        and candidate.status = 'active'
+        and ${validEvidence(CANDIDATE)}
+    )`
+  }).from(decisionEpisodes).where(and7(
+    eq7(decisionEpisodes.status, "active"),
+    validEvidence(),
+    competingActive()
+  )).orderBy(sql7`${CREATED_MS} desc`, asc6(decisionEpisodes.id));
+  const families2 = /* @__PURE__ */ new Map();
+  for (const { members, ...row } of rows) {
+    const family = families2.get(members) ?? [];
+    family.push(asEpisode(row));
+    families2.set(members, family);
+  }
+  return [...families2.values()];
+}
+async function decisionEpisodeById(db, id) {
+  const [row] = await db.select().from(decisionEpisodes).where(and7(eq7(decisionEpisodes.id, id), validEvidence())).limit(1);
+  return row ? asEpisode(row) : void 0;
+}
+function familyIds(id) {
+  return sql7`with recursive family(id) as (
+    select ${id}::text
+    union
+    select case when edge.id = family.id then edge.supersedes_id else edge.id end
+    from decision_episodes edge inner join family
+      on edge.id = family.id or edge.supersedes_id = family.id
+    where case when edge.id = family.id then edge.supersedes_id else edge.id end is not null
+  ) select id from family`;
+}
+async function activeSuccessor(db, id) {
+  const [row] = await db.select().from(decisionEpisodes).where(and7(
+    sql7`${decisionEpisodes.id} in (${familyIds(id)})`,
+    sql7`${decisionEpisodes.id} <> ${id}`,
+    eq7(decisionEpisodes.status, "active"),
+    validEvidence()
+  )).orderBy(desc6(decisionEpisodes.createdAt), asc6(decisionEpisodes.id)).limit(1);
+  return row ? asEpisode(row) : void 0;
+}
+async function activeEpisodeRevisions(db, ids) {
+  const revisions = {};
+  const unique = [...new Set(ids)];
+  for (let offset = 0; offset < unique.length; offset += CHUNK) {
+    const rows = await db.select({ id: decisionEpisodes.id, activeId: sql7`(
+      select candidate.id from decision_episodes candidate
+      where candidate.id in (${familyIds(sql7`decision_episodes.id`)})
+        and candidate.id <> decision_episodes.id and candidate.status = 'active'
+        and ${validEvidence(CANDIDATE)}
+      order by candidate.created_at desc, candidate.id asc limit 1
+    )` }).from(decisionEpisodes).where(inArray6(decisionEpisodes.id, unique.slice(offset, offset + CHUNK)));
+    for (const row of rows) if (row.activeId) revisions[row.id] = row.activeId;
+  }
+  return revisions;
+}
+async function decisionEpisodeCount(db) {
+  const [row] = await db.select({ count: sql7`count(*)::int` }).from(decisionEpisodes).where(and7(eq7(decisionEpisodes.status, "active"), validEvidence()));
+  return row?.count ?? 0;
+}
+async function setDecisionEpisodeStatus(db, id, status, options = {}) {
+  if (status !== "active" && status !== "dismissed") throw new Error("Unknown decision episode status.");
+  return episodeWrite(db, async (tx) => {
+    const existing = await decisionEpisodeById(tx, id);
+    if (!existing || existing.status === status) return false;
+    if (options.expectedUpdatedAt && existing.updatedAt.getTime() !== options.expectedUpdatedAt.getTime()) {
+      throw new DecisionEpisodeConflict("stale");
+    }
+    if (status === "active" && await activeSuccessor(tx, id)) throw new DecisionEpisodeConflict("activeSuccessor");
+    const rows = await tx.update(decisionEpisodes).set({ status, updatedAt: sql7`greatest(current_timestamp, ${decisionEpisodes.updatedAt} + interval '1 millisecond')` }).where(and7(
+      eq7(decisionEpisodes.id, id),
+      validEvidence(),
+      eq7(decisionEpisodes.status, existing.status)
+    )).returning({ id: decisionEpisodes.id });
+    return rows.length > 0;
+  });
+}
+async function setDecisionEpisodeValidUntil(db, id, validUntil, options = {}) {
+  if (validUntil !== null && !Number.isFinite(validUntil.getTime())) throw new Error("A decision episode expiry must be a valid instant.");
+  return episodeWrite(db, async (tx) => {
+    const existing = await decisionEpisodeById(tx, id);
+    if (!existing) return false;
+    const stored = existing.validUntil ? existing.validUntil.getTime() : null;
+    if (stored === (validUntil ? validUntil.getTime() : null)) return false;
+    if (options.expectedUpdatedAt && existing.updatedAt.getTime() !== options.expectedUpdatedAt.getTime()) {
+      throw new DecisionEpisodeConflict("stale");
+    }
+    const rows = await tx.update(decisionEpisodes).set({ validUntil, updatedAt: sql7`greatest(current_timestamp, ${decisionEpisodes.updatedAt} + interval '1 millisecond')` }).where(and7(
+      eq7(decisionEpisodes.id, id),
+      validEvidence()
+    )).returning({ id: decisionEpisodes.id });
+    return rows.length > 0;
+  });
+}
+
+// src/memory-jobs.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { and as and8, asc as asc7, desc as desc7, eq as eq8, isNotNull as isNotNull3, lte, sql as sql8 } from "drizzle-orm";
+var MEMORY_JOB_MAX_ATTEMPTS = 3;
+var MEMORY_JOB_LEASE_MS = 5 * 6e4;
+var MEMORY_SESSION_WINDOW = 100;
+async function enqueueMemoryJob(db, sessionId) {
+  const [session] = await db.select({ id: agentSessions.id }).from(agentSessions).where(and8(eq8(agentSessions.id, sessionId), isNotNull3(agentSessions.endedAt))).limit(1);
+  if (!session) return false;
+  const inserted = await db.insert(memoryJobs).values({ sessionId }).onConflictDoNothing().returning({ sessionId: memoryJobs.sessionId });
+  return inserted.length > 0;
+}
+async function claimMemoryJob(db, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const leaseMs = options.leaseMs ?? MEMORY_JOB_LEASE_MS;
+  if (!Number.isFinite(now.getTime()) || !Number.isFinite(leaseMs) || leaseMs < 1) throw new Error("Invalid memory job lease.");
+  const expiredBefore = new Date(now.getTime() - leaseMs);
+  return db.transaction(async (tx) => {
+    await tx.execute(sql8`lock table ${memoryJobs} in share row exclusive mode`);
+    await tx.update(memoryJobs).set({ status: "failed", reason: "leaseExpired", leaseToken: null, finishedAt: now }).where(and8(
+      eq8(memoryJobs.status, "running"),
+      lte(memoryJobs.startedAt, expiredBefore),
+      sql8`${memoryJobs.attempts} >= ${MEMORY_JOB_MAX_ATTEMPTS}`
+    ));
+    const [job] = await tx.select({
+      sessionId: memoryJobs.sessionId,
+      attempts: memoryJobs.attempts,
+      projectId: agentSessions.projectId,
+      identity: projects.identity,
+      root: projects.root
+    }).from(memoryJobs).innerJoin(agentSessions, eq8(agentSessions.id, memoryJobs.sessionId)).innerJoin(projects, eq8(projects.id, agentSessions.projectId)).where(and8(
+      isNotNull3(agentSessions.endedAt),
+      sql8`${memoryJobs.attempts} < ${MEMORY_JOB_MAX_ATTEMPTS}`,
+      sql8`(( ${memoryJobs.status} in ('pending', 'deferred', 'failed') and ${memoryJobs.availableAt} <= ${now})
+          or (${memoryJobs.status} = 'running' and ${memoryJobs.startedAt} <= ${expiredBefore}))`
+    )).orderBy(asc7(memoryJobs.availableAt), asc7(memoryJobs.createdAt), asc7(memoryJobs.sessionId)).limit(1);
+    if (!job) return void 0;
+    const leaseToken = randomUUID3();
+    await tx.update(memoryJobs).set({
+      status: "running",
+      attempts: job.attempts + 1,
+      startedAt: now,
+      finishedAt: null,
+      leaseToken,
+      reason: null
+    }).where(eq8(memoryJobs.sessionId, job.sessionId));
+    return { ...job, attempts: job.attempts + 1, leaseToken };
+  });
+}
+async function withMemoryJobLease(db, sessionId, leaseToken, work, expectedProjectId) {
+  return db.transaction(async (tx) => {
+    const [job] = await tx.select({ sessionId: memoryJobs.sessionId }).from(memoryJobs).innerJoin(agentSessions, eq8(agentSessions.id, memoryJobs.sessionId)).where(and8(
+      eq8(memoryJobs.sessionId, sessionId),
+      eq8(memoryJobs.status, "running"),
+      eq8(memoryJobs.leaseToken, leaseToken),
+      expectedProjectId === void 0 ? void 0 : eq8(agentSessions.projectId, expectedProjectId)
+    )).for("update");
+    if (!job) return { current: false };
+    return { current: true, value: await work(tx) };
+  });
+}
+async function finishMemoryJob(db, sessionId, leaseToken, result) {
+  if (!["complete", "deferred", "failed"].includes(result.status)) throw new Error("Invalid memory job result.");
+  if (result.consumeAttempt === false && result.status !== "deferred") throw new Error("Only deferred work can refund an attempt.");
+  if (result.retriesLeft !== void 0 && (result.status !== "failed" || result.consumeAttempt === false)) throw new Error("Only failed work can cap its retries.");
+  if (result.retriesLeft !== void 0 && (!Number.isInteger(result.retriesLeft) || result.retriesLeft < 0 || result.retriesLeft >= MEMORY_JOB_MAX_ATTEMPTS)) throw new Error("Memory job retries must fit under the attempt ceiling.");
+  if (result.runAfter && !Number.isFinite(result.runAfter.getTime())) throw new Error("Invalid memory retry date.");
+  if (result.reason && !/^[a-zA-Z][a-zA-Z0-9_-]{0,79}$/.test(result.reason)) throw new Error("Memory job reasons must be bounded codes.");
+  const now = /* @__PURE__ */ new Date();
+  const rows = await db.update(memoryJobs).set({
+    status: result.status,
+    reason: result.reason ?? null,
+    finishedAt: now,
+    leaseToken: null,
+    ...result.receipt === void 0 ? {} : { receipt: result.receipt },
+    ...result.consumeAttempt === false ? { attempts: sql8`greatest(0, ${memoryJobs.attempts} - 1)` } : {},
+    ...result.retriesLeft === void 0 ? {} : { attempts: sql8`greatest(${memoryJobs.attempts}, ${MEMORY_JOB_MAX_ATTEMPTS - result.retriesLeft})` },
+    availableAt: result.runAfter ?? sql8`${now}::timestamptz + (interval '1 minute' * power(2, greatest(0, ${memoryJobs.attempts} - 1)))`
+  }).where(and8(eq8(memoryJobs.sessionId, sessionId), eq8(memoryJobs.status, "running"), eq8(memoryJobs.leaseToken, leaseToken))).returning({ sessionId: memoryJobs.sessionId });
+  return rows.length > 0;
+}
+async function memoryJobCounts(db, projectId) {
+  const [counts] = await db.select({
+    pending: sql8`count(*) filter (where ${memoryJobs.status} = 'pending')::int`,
+    running: sql8`count(*) filter (where ${memoryJobs.status} = 'running')::int`,
+    deferred: sql8`count(*) filter (where ${memoryJobs.status} = 'deferred')::int`,
+    failed: sql8`count(*) filter (where ${memoryJobs.status} = 'failed')::int`,
+    complete: sql8`count(*) filter (where ${memoryJobs.status} = 'complete')::int`
+  }).from(memoryJobs).innerJoin(agentSessions, eq8(agentSessions.id, memoryJobs.sessionId)).where(projectId === void 0 ? void 0 : eq8(agentSessions.projectId, projectId));
+  return counts ?? { pending: 0, running: 0, deferred: 0, failed: 0, complete: 0 };
+}
+async function latestProjectMemoryJob(db, projectId) {
+  const [job] = await db.select({
+    sessionId: memoryJobs.sessionId,
+    status: memoryJobs.status,
+    reason: memoryJobs.reason,
+    attempts: memoryJobs.attempts,
+    receipt: memoryJobs.receipt,
+    availableAt: memoryJobs.availableAt,
+    finishedAt: memoryJobs.finishedAt
+  }).from(memoryJobs).innerJoin(agentSessions, eq8(agentSessions.id, memoryJobs.sessionId)).where(eq8(agentSessions.projectId, projectId)).orderBy(desc7(memoryJobs.createdAt), desc7(memoryJobs.sessionId)).limit(1);
+  return job;
+}
+async function sessionMemoryWindow(db, sessionId) {
+  const rows = await db.select({
+    total: sql8`(count(*) over ())::int`,
+    kind: agentActivities.kind,
+    summary: agentActivities.summary,
+    details: agentActivities.details,
+    filesTouched: agentActivities.filesTouched
+  }).from(agentActivities).where(eq8(agentActivities.sessionId, sessionId)).orderBy(desc7(agentActivities.createdAt), desc7(agentActivities.id)).limit(MEMORY_SESSION_WINDOW);
+  const total = rows[0]?.total ?? 0;
+  return {
+    activities: rows.reverse().map(({ kind, summary, details, filesTouched }) => ({ kind, summary, details, filesTouched })),
+    total,
+    omitted: Math.max(0, total - rows.length)
+  };
+}
+
+// src/memory-export.ts
+import { asc as asc8, desc as desc8, eq as eq9, isNull as isNull4, sql as sql9 } from "drizzle-orm";
+var MEMORY_EXPORT_VERSION = 1;
+function iso(date) {
+  return date ? date.toISOString() : null;
+}
+async function decisionsOf(db, identity) {
+  const rows = await db.select({
+    id: decisionEpisodes.id,
+    identity: decisionEpisodes.identity,
+    supersedesId: decisionEpisodes.supersedesId,
+    origin: decisionEpisodes.origin,
+    fields: decisionEpisodes.fields,
+    model: decisionEpisodes.model,
+    status: decisionEpisodes.status,
+    validUntil: decisionEpisodes.validUntil,
+    createdAt: decisionEpisodes.createdAt,
+    updatedAt: decisionEpisodes.updatedAt,
+    evidenceValid: sql9`(${decisionEpisodes.origin} = 'owner' or not exists (
+        select 1 from jsonb_each(${decisionEpisodes.fields}) as field(name, evidence)
+        left join ${narratives} on ${narratives.id} = field.evidence->>'narrativeId'
+        where ${narratives.id} is null
+          or ${narratives.identity} is distinct from ${decisionEpisodes.identity}
+      ))`
+  }).from(decisionEpisodes).where(identity === null ? isNull4(decisionEpisodes.identity) : eq9(decisionEpisodes.identity, identity)).orderBy(desc8(decisionEpisodes.createdAt), asc8(decisionEpisodes.id));
+  const revisions = await activeEpisodeRevisions(db, rows.map((row) => row.id));
+  return rows.map((row) => ({
+    id: row.id,
+    identity: row.identity,
+    supersedesId: row.supersedesId,
+    activeRevisionId: revisions[row.id] ?? null,
+    evidenceValid: row.evidenceValid,
+    origin: row.origin,
+    fields: row.fields,
+    model: row.model,
+    status: row.status,
+    // An expired decision travels too: it stopped reaching agents, it did not stop being history.
+    validUntil: iso(row.validUntil),
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString()
+  }));
+}
+async function exportProjectMemory(db, project) {
+  const notes2 = await db.select({
+    id: notes.id,
+    body: notes.body,
+    status: notes.status,
+    createdBy: notes.createdBy,
+    createdAt: notes.createdAt,
+    decidedAt: notes.decidedAt,
+    trigger: notes.trigger,
+    sentinels: notes.sentinels,
+    challenge: notes.challenge
+  }).from(notes).where(eq9(notes.projectId, project.id)).orderBy(desc8(notes.createdAt), asc8(notes.id));
+  const [decisions2, generalDecisions, counts] = await Promise.all([
+    project.identity === null ? Promise.resolve([]) : decisionsOf(db, project.identity),
+    decisionsOf(db, null),
+    memoryJobCounts(db, project.id)
+  ]);
+  const jobs = await db.select({
+    sessionId: memoryJobs.sessionId,
+    status: memoryJobs.status,
+    reason: memoryJobs.reason,
+    attempts: memoryJobs.attempts,
+    availableAt: memoryJobs.availableAt,
+    startedAt: memoryJobs.startedAt,
+    finishedAt: memoryJobs.finishedAt,
+    receipt: memoryJobs.receipt
+  }).from(memoryJobs).innerJoin(agentSessions, eq9(agentSessions.id, memoryJobs.sessionId)).where(eq9(agentSessions.projectId, project.id)).orderBy(desc8(memoryJobs.createdAt), desc8(memoryJobs.sessionId));
+  return {
+    version: MEMORY_EXPORT_VERSION,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    project: {
+      id: project.id,
+      slug: project.slug,
+      name: project.name,
+      root: project.root,
+      identity: project.identity
+    },
+    notes: notes2.map((note) => ({
+      id: note.id,
+      body: note.body,
+      status: note.status,
+      createdBy: note.createdBy,
+      createdAt: note.createdAt.toISOString(),
+      decidedAt: iso(note.decidedAt),
+      where: note.trigger,
+      anchors: note.sentinels,
+      challenge: note.challenge
+    })),
+    decisions: decisions2,
+    generalDecisions,
+    receipts: {
+      counts,
+      jobs: jobs.map((job) => ({
+        sessionId: job.sessionId,
+        status: job.status,
+        reason: job.reason,
+        attempts: job.attempts,
+        availableAt: job.availableAt.toISOString(),
+        startedAt: iso(job.startedAt),
+        finishedAt: iso(job.finishedAt),
+        receipt: job.receipt ?? null
+      }))
+    }
+  };
+}
+
 // src/runs.ts
-import { and as and6, desc as desc5, eq as eq6, lt, sql as sql6 } from "drizzle-orm";
+import { and as and9, desc as desc9, eq as eq10, lt as lt2, sql as sql10 } from "drizzle-orm";
 async function createRun(db, input) {
   const id = newId("run");
   await db.insert(runs).values({
@@ -2893,10 +3856,10 @@ async function createRun(db, input) {
   return id;
 }
 async function finishRun(db, id, outcome) {
-  await db.update(runs).set({ ...outcome, finishedAt: /* @__PURE__ */ new Date() }).where(eq6(runs.id, id));
+  await db.update(runs).set({ ...outcome, finishedAt: /* @__PURE__ */ new Date() }).where(eq10(runs.id, id));
 }
 async function setRunStatus(db, id, status) {
-  await db.update(runs).set({ status }).where(eq6(runs.id, id));
+  await db.update(runs).set({ status }).where(eq10(runs.id, id));
 }
 var RUN_TIMEOUT_MS = 20 * 60 * 1e3;
 async function reapStaleRuns(db) {
@@ -2905,15 +3868,15 @@ async function reapStaleRuns(db) {
     status: "failed",
     summary: "Interrumpida: el proceso que la ejecutaba desapareci\xF3 sin dejar resultado. No sabemos por d\xF3nde iba, as\xED que no se puede afirmar nada sobre el paquete.",
     finishedAt: /* @__PURE__ */ new Date()
-  }).where(and6(eq6(runs.status, "running"), lt(runs.createdAt, cutoff))).returning({ id: runs.id });
+  }).where(and9(eq10(runs.status, "running"), lt2(runs.createdAt, cutoff))).returning({ id: runs.id });
   return stale.length;
 }
 async function findRunningRun(db, projectId) {
-  const [row] = await db.select({ id: runs.id, createdAt: runs.createdAt }).from(runs).where(and6(eq6(runs.projectId, projectId), eq6(runs.status, "running"))).orderBy(desc5(runs.createdAt)).limit(1);
+  const [row] = await db.select({ id: runs.id, createdAt: runs.createdAt }).from(runs).where(and9(eq10(runs.projectId, projectId), eq10(runs.status, "running"))).orderBy(desc9(runs.createdAt)).limit(1);
   return row;
 }
 async function getRun(db, id) {
-  const [row] = await db.select().from(runs).where(eq6(runs.id, id)).limit(1);
+  const [row] = await db.select().from(runs).where(eq10(runs.id, id)).limit(1);
   return row;
 }
 async function getRunWithProject(db, id) {
@@ -2937,7 +3900,7 @@ async function getRunWithProject(db, id) {
     projectName: projects.name,
     projectSlug: projects.slug,
     projectRoot: projects.root
-  }).from(runs).innerJoin(projects, eq6(projects.id, runs.projectId)).where(eq6(runs.id, id)).limit(1);
+  }).from(runs).innerJoin(projects, eq10(projects.id, runs.projectId)).where(eq10(runs.id, id)).limit(1);
   return row;
 }
 async function listProjectRuns(db, projectId) {
@@ -2955,7 +3918,7 @@ async function listProjectRuns(db, projectId) {
     requestedBy: runs.requestedBy,
     createdAt: runs.createdAt,
     finishedAt: runs.finishedAt
-  }).from(runs).where(eq6(runs.projectId, projectId)).orderBy(desc5(runs.createdAt)).limit(50);
+  }).from(runs).where(eq10(runs.projectId, projectId)).orderBy(desc9(runs.createdAt)).limit(50);
 }
 async function listAllRuns(db, limit = 100) {
   return db.select({
@@ -2972,14 +3935,14 @@ async function listAllRuns(db, limit = 100) {
     createdAt: runs.createdAt,
     projectName: projects.name,
     projectSlug: projects.slug
-  }).from(runs).innerJoin(projects, eq6(projects.id, runs.projectId)).orderBy(desc5(runs.createdAt)).limit(limit);
+  }).from(runs).innerJoin(projects, eq10(projects.id, runs.projectId)).orderBy(desc9(runs.createdAt)).limit(limit);
 }
 async function findUpgradeTarget(db, projectId, packageName) {
   const [row] = await db.select({
     latestVersion: packages.latestVersion,
     ecosystem: packages.ecosystem
-  }).from(projectDependencies).innerJoin(packages, eq6(packages.id, projectDependencies.packageId)).where(
-    and6(eq6(projectDependencies.projectId, projectId), eq6(packages.name, packageName))
+  }).from(projectDependencies).innerJoin(packages, eq10(packages.id, projectDependencies.packageId)).where(
+    and9(eq10(projectDependencies.projectId, projectId), eq10(packages.name, packageName))
   ).limit(1);
   return row?.latestVersion ? { latestVersion: row.latestVersion, ecosystem: row.ecosystem } : void 0;
 }
@@ -2990,13 +3953,13 @@ async function findKnownFailure(db, projectId, packageName, targetVersion) {
     createdAt: runs.createdAt,
     steps: runs.steps
   }).from(runs).where(
-    and6(
-      eq6(runs.projectId, projectId),
-      eq6(runs.status, "failed"),
-      sql6`${runs.target}->>'packageName' = ${packageName}`,
-      sql6`${runs.target}->>'targetVersion' = ${targetVersion}`
+    and9(
+      eq10(runs.projectId, projectId),
+      eq10(runs.status, "failed"),
+      sql10`${runs.target}->>'packageName' = ${packageName}`,
+      sql10`${runs.target}->>'targetVersion' = ${targetVersion}`
     )
-  ).orderBy(desc5(runs.createdAt)).limit(1);
+  ).orderBy(desc9(runs.createdAt)).limit(1);
   return row;
 }
 async function listSecurityTargets(db, projectId) {
@@ -3008,13 +3971,13 @@ async function listSecurityTargets(db, projectId) {
     severity: advisories.severity,
     summary: advisories.summary,
     fixedVersions: advisories.fixedVersions
-  }).from(projectDependencies).innerJoin(packages, eq6(packages.id, projectDependencies.packageId)).innerJoin(
+  }).from(projectDependencies).innerJoin(packages, eq10(packages.id, projectDependencies.packageId)).innerJoin(
     vulnerabilities,
-    and6(
-      eq6(vulnerabilities.packageId, projectDependencies.packageId),
-      eq6(vulnerabilities.version, projectDependencies.resolvedVersion)
+    and9(
+      eq10(vulnerabilities.packageId, projectDependencies.packageId),
+      eq10(vulnerabilities.version, projectDependencies.resolvedVersion)
     )
-  ).innerJoin(advisories, eq6(advisories.id, vulnerabilities.advisoryId)).where(eq6(projectDependencies.projectId, projectId));
+  ).innerJoin(advisories, eq10(advisories.id, vulnerabilities.advisoryId)).where(eq10(projectDependencies.projectId, projectId));
   const targets = [];
   for (const row of rows) {
     const fixes = Array.isArray(row.fixedVersions) ? row.fixedVersions : [];
@@ -3037,16 +4000,31 @@ export {
   CONSULT_MAX,
   CONSULT_PENDING_MAX,
   DORMANT_DAYS,
+  DecisionEpisodeConflict,
+  EPISODE_FIELDS,
   IDLE_DAYS,
+  LIVE_APP_JOBS,
   LOG_DETAILS_MAX,
   LOG_SUMMARY_MAX,
+  MAX_APP_SPEND_CALLS,
+  MEMORY_EXPORT_VERSION,
+  MEMORY_JOB_LEASE_MS,
+  MEMORY_JOB_MAX_ATTEMPTS,
+  MEMORY_SESSION_WINDOW,
+  MIN_DISTILL_CITATIONS,
   NOTE_BUDGET,
   NOTE_MAX,
   NOTE_PENDING_MAX,
   NOTE_SLEEPING_MAX,
   SNAPSHOTS_PER_PROJECT,
+  STALE_MAX_DAYS,
   SUPPORT_FLOOR,
+  activeEpisodeRevisions,
+  activeSuccessor,
   addHumanNote,
+  appDedupeKey,
+  appJobTransition,
+  appProject,
   assignedCritiques,
   assignedFindings,
   authenticateAgent,
@@ -3054,8 +4032,11 @@ export {
   beliefChurn,
   bridgeCounts,
   briefScore,
+  canonicalAppInput,
   challengeNote,
   citedVerdictIds,
+  claimAppJob,
+  claimMemoryJob,
   claimTask,
   closeSession,
   completeTask,
@@ -3064,27 +4045,41 @@ export {
   createRun,
   createTask,
   decideNote,
+  decisionEpisodeById,
+  decisionEpisodeCount,
   deleteAgent,
+  deleteNarratives,
   deleteVerdicts,
   discardTask,
   discardedCritiques,
   discardedFindings,
   doubleReport,
   draftConsultation,
+  draftingConsultation,
+  enqueueAppJobRow,
+  enqueueMemoryJob,
+  ensureApp,
   esquina,
   excludeProject,
+  exportProjectMemory,
   familia,
   findKnownFailure,
   findRunningRun,
   findUpgradeTarget,
+  finishMemoryJob,
   finishRun,
+  forgetAppWorkspaces,
   forgetProjectsUnder,
   getAgentContext,
+  getApp,
+  getAppJob,
+  getAppWorkspace,
   getDailyReport,
   getDesignFingerprint,
   getDiskTotals,
   getLook,
   getNorth,
+  getOpenContext,
   getProject,
   getProjectIcon,
   getProjectLocation,
@@ -3093,20 +4088,29 @@ export {
   getRunWithProject,
   getStats,
   getTask,
+  hasPendingAppJob,
   idFor,
   inTransaction,
   ingestPortfolio,
   insertBeliefs,
   labelConsultation,
+  latestProjectMemoryJob,
+  latestSynthesisByTopic,
   launchedTasks,
   listAgents,
   listAllActivity,
   listAllRuns,
+  listAppJobs,
+  listApps,
   listBeliefs,
+  listConflictingEpisodeFamilies,
+  listDecisionEpisodes,
   listDiskUsage,
   listFamilies,
   listHidden,
   listLooks,
+  listModelCalls,
+  listNarratives,
   listObservations,
   listPackages,
   listProjectActivity,
@@ -3119,30 +4123,38 @@ export {
   listProjects,
   listSecurityTargets,
   listSentinels,
-  listSessionActivities,
   listUnsavedWork,
   listVerdicts,
   logActivity,
   lookedAt,
+  markNarrativesFailed,
+  markNarrativesRead,
   markPublished,
   markVerdictsDistilled,
+  memoryJobCounts,
   modelSpendByKind,
+  modelSpendByModel,
   modelSpendToday,
   monthOf,
+  narrativeCount,
+  narrativesByIds,
   neverReviewed,
   newId,
   noteUsage,
   notesAt,
   observationTopics,
   openSession,
+  pendingConsultations,
   portfolioDesign,
   projectByIdentity,
   projectNamesByIdentity,
   proposeNote,
   pruneSnapshots,
   queueWrite,
+  readJournalEntry,
   readVerdictIds,
   reapStaleRuns,
+  recordAppSpend,
   recordConsultation,
   recordLaunch,
   recordServing,
@@ -3150,16 +4162,21 @@ export {
   resolveProject,
   resolveProposal,
   retireBeliefs,
+  revalidateAppBudget,
   rotateAgentKey,
   saveAiSummary,
+  saveAppWorkspace,
   saveBuildCheck,
+  saveDecisionEpisodes,
   saveDesignFingerprint,
   saveDiskUsage,
   saveLook,
   saveMdReview,
   saveModelCall,
+  saveNarratives,
   saveNorth,
   saveObservations,
+  saveOpenPlan,
   saveProjectAccounts,
   saveReview,
   saveSynthesisPass,
@@ -3167,8 +4184,12 @@ export {
   scaleReport,
   schema_exports as schema,
   searchJournal,
+  searchJournalPage,
+  sessionMemoryWindow,
   setBeliefScope,
   setBeliefTopics,
+  setDecisionEpisodeStatus,
+  setDecisionEpisodeValidUntil,
   setHidden,
   setObservationTopics,
   setRunStatus,
@@ -3181,9 +4202,14 @@ export {
   stateOf,
   tasteReach,
   tasteScore,
+  transitionAppJob,
   triggerMatches,
   unexcludeProject,
+  updateApp,
+  updateAppJobProgress,
   updateBelief,
+  validMemoryPath,
   validTrigger,
-  vetoBelief
+  vetoBelief,
+  withMemoryJobLease
 };