nodal-agents 0.6.8 → 0.7.0

package/cli.js

@@ -11511,6 +11511,10 @@ var init_memory = __esm({
       valid_to: z13.string().datetime().nullable(),
       fact_hash: z13.string().nullable(),
       archived: z13.boolean(),
+      // User override lock (migration 0053) — when true, the curator refuses to
+      // re-score importance for this fact. Defaulted so rows/objects predating
+      // the column still parse.
+      importance_locked: z13.boolean().default(false),
       last_accessed_at: z13.string().datetime().nullable(),
       access_count: z13.number().int().min(0),
       created_at: z13.string().datetime(),
@@ -11522,6 +11526,7 @@ var init_memory = __esm({
       updated_at: true,
       fact_hash: true,
       archived: true,
+      importance_locked: true,
       last_accessed_at: true,
       access_count: true,
       valid_from: true,
@@ -12330,6 +12335,10 @@ var init_entities = __esm({
         updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow(),
         lastCuratorRunAt: timestamp("last_curator_run_at", { withTimezone: true }),
         reflectionEnabled: boolean("reflection_enabled").notNull().default(false),
+        // Decoupled from reflection_enabled (which gates the skill-learning loop,
+        // opt-in). Gates the memory curator (Phase 2 LLM pass) — ON by default so
+        // memory curation runs even for entities that never opted into reflection.
+        memoryCurationEnabled: boolean("memory_curation_enabled").notNull().default(true),
         // Controls whether agent-authored skills are auto-assigned to the authoring
         // agent ('auto') or queued for the entity owner to approve ('approval').
         skillAssignmentMode: text("skill_assignment_mode").notNull().default("approval").$type(),
@@ -12886,6 +12895,15 @@ var init_memory2 = __esm({
         id: uuid("id").primaryKey().defaultRandom(),
         entityId: uuid("entity_id").references(() => entities.id, { onDelete: "cascade" }),
         agentId: uuid("agent_id").references(() => agents.id, { onDelete: "cascade" }),
+        /**
+         * Full-text source. A generated `search_tsv tsvector` column + GIN index
+         * (raw SQL, migration 0051 — not expressible in the Drizzle schema builder,
+         * same pattern as agent_jobs.search_tsv / migration 0050) makes this fact
+         * rankable by relevance. Powers memory injection (selectMemoriesForInjection)
+         * and the `query_memory` builtin (keywordSearchMemories) via ts_rank.
+         * Config is `'english'` (stemming — "tokens" matches a "token" query),
+         * unlike agent_jobs.search_tsv which stays `'simple'`.
+         */
         fact: text("fact").notNull(),
         category: text("category").default("context"),
         importance: integer("importance").default(3),
@@ -12897,6 +12915,12 @@ var init_memory2 = __esm({
         validTo: timestamp("valid_to", { withTimezone: true }),
         factHash: text("fact_hash"),
         archived: boolean("archived").default(false),
+        /**
+         * User override lock (migration 0053). When true, the curator's
+         * usage-driven re-scoring MUST refuse to touch importance — a user-pinned
+         * value wins over the agent's guess and the curator's correction.
+         */
+        importanceLocked: boolean("importance_locked").notNull().default(false),
         lastAccessedAt: timestamp("last_accessed_at", { withTimezone: true }).defaultNow(),
         accessCount: integer("access_count").default(0),
         createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),

package/migrations/0051_memory_search_fts.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "agent_memory" ADD COLUMN "search_tsv" tsvector GENERATED ALWAYS AS (to_tsvector('english', coalesce("fact", ''))) STORED;--> statement-breakpoint
+CREATE INDEX "idx_agent_memory_search_tsv" ON "agent_memory" USING gin ("search_tsv");

package/migrations/0052_entities_memory_curation.sql

@@ -0,0 +1 @@
+ALTER TABLE "entities" ADD COLUMN "memory_curation_enabled" boolean NOT NULL DEFAULT true;

package/migrations/0053_memory_importance_locked.sql

@@ -0,0 +1 @@
+ALTER TABLE "agent_memory" ADD COLUMN "importance_locked" boolean NOT NULL DEFAULT false;

package/migrations/meta/_journal.json

@@ -351,6 +351,27 @@
       "when": 1783000000000,
       "tag": "0050_jobs_search_fts",
       "breakpoints": true
+    },
+    {
+      "idx": 51,
+      "version": "7",
+      "when": 1783100000000,
+      "tag": "0051_memory_search_fts",
+      "breakpoints": true
+    },
+    {
+      "idx": 52,
+      "version": "7",
+      "when": 1783200000000,
+      "tag": "0052_entities_memory_curation",
+      "breakpoints": true
+    },
+    {
+      "idx": 53,
+      "version": "7",
+      "when": 1783300000000,
+      "tag": "0053_memory_importance_locked",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodal-agents",
-  "version": "0.6.8",
+  "version": "0.7.0",
   "description": "Local-first AI agent platform with a web dashboard — install in one command.",
   "license": "MIT",
   "repository": {

package/runner.js

@@ -574,6 +574,10 @@ var init_memory = __esm({
       valid_to: z13.string().datetime().nullable(),
       fact_hash: z13.string().nullable(),
       archived: z13.boolean(),
+      // User override lock (migration 0053) — when true, the curator refuses to
+      // re-score importance for this fact. Defaulted so rows/objects predating
+      // the column still parse.
+      importance_locked: z13.boolean().default(false),
       last_accessed_at: z13.string().datetime().nullable(),
       access_count: z13.number().int().min(0),
       created_at: z13.string().datetime(),
@@ -585,6 +589,7 @@ var init_memory = __esm({
       updated_at: true,
       fact_hash: true,
       archived: true,
+      importance_locked: true,
       last_accessed_at: true,
       access_count: true,
       valid_from: true,
@@ -1593,6 +1598,10 @@ var init_entities = __esm({
         updatedAt: timestamp2("updated_at", { withTimezone: true }).defaultNow(),
         lastCuratorRunAt: timestamp2("last_curator_run_at", { withTimezone: true }),
         reflectionEnabled: boolean2("reflection_enabled").notNull().default(false),
+        // Decoupled from reflection_enabled (which gates the skill-learning loop,
+        // opt-in). Gates the memory curator (Phase 2 LLM pass) — ON by default so
+        // memory curation runs even for entities that never opted into reflection.
+        memoryCurationEnabled: boolean2("memory_curation_enabled").notNull().default(true),
         // Controls whether agent-authored skills are auto-assigned to the authoring
         // agent ('auto') or queued for the entity owner to approve ('approval').
         skillAssignmentMode: text2("skill_assignment_mode").notNull().default("approval").$type(),
@@ -2190,6 +2199,15 @@ var init_memory2 = __esm({
         id: uuid11("id").primaryKey().defaultRandom(),
         entityId: uuid11("entity_id").references(() => entities.id, { onDelete: "cascade" }),
         agentId: uuid11("agent_id").references(() => agents.id, { onDelete: "cascade" }),
+        /**
+         * Full-text source. A generated `search_tsv tsvector` column + GIN index
+         * (raw SQL, migration 0051 — not expressible in the Drizzle schema builder,
+         * same pattern as agent_jobs.search_tsv / migration 0050) makes this fact
+         * rankable by relevance. Powers memory injection (selectMemoriesForInjection)
+         * and the `query_memory` builtin (keywordSearchMemories) via ts_rank.
+         * Config is `'english'` (stemming — "tokens" matches a "token" query),
+         * unlike agent_jobs.search_tsv which stays `'simple'`.
+         */
         fact: text11("fact").notNull(),
         category: text11("category").default("context"),
         importance: integer5("importance").default(3),
@@ -2201,6 +2219,12 @@ var init_memory2 = __esm({
         validTo: timestamp11("valid_to", { withTimezone: true }),
         factHash: text11("fact_hash"),
         archived: boolean6("archived").default(false),
+        /**
+         * User override lock (migration 0053). When true, the curator's
+         * usage-driven re-scoring MUST refuse to touch importance — a user-pinned
+         * value wins over the agent's guess and the curator's correction.
+         */
+        importanceLocked: boolean6("importance_locked").notNull().default(false),
         lastAccessedAt: timestamp11("last_accessed_at", { withTimezone: true }).defaultNow(),
         accessCount: integer5("access_count").default(0),
         createdAt: timestamp11("created_at", { withTimezone: true }).defaultNow(),
@@ -17705,6 +17729,17 @@ var envSchema = z.object({
   CURATOR_MEMORY_STALE_DAYS: z.coerce.number().default(60),
   CURATOR_MEMORY_IMPORTANCE_MAX: z.coerce.number().default(2),
   CURATOR_MEMORY_MIN: z.coerce.number().default(8),
+  // Kill-switch semantics mirror REFLECTION_ENABLED but gate the MEMORY curator
+  // (Phase 2 LLM pass) specifically — decoupled from the skill-learning loop:
+  //   MEMORY_CURATION_ENABLED='false'  → global kill: disables memory curation
+  //                                       for every entity.
+  //   MEMORY_CURATION_ENABLED=''       → per-entity decides (production default
+  //       (unset)                         when the var is absent). Since
+  //                                       entities.memory_curation_enabled
+  //                                       defaults TRUE, memory curation runs
+  //                                       out of the box — unlike reflection.
+  //   MEMORY_CURATION_ENABLED='true'   → per-entity decides (same as unset).
+  MEMORY_CURATION_ENABLED: z.string().default(""),
   // Optional. When set, the reflection + curator passes use THIS model id instead of
   // the agent's model — resolved against the agent's existing LLM key (ideal for an
   // OpenRouter key where one key serves many models; point the cheap/reliable
@@ -20026,6 +20061,7 @@ function rowToMemory(row) {
     valid_to: row.validTo?.toISOString() ?? null,
     fact_hash: row.factHash ?? null,
     archived: row.archived ?? false,
+    importance_locked: row.importanceLocked ?? false,
     last_accessed_at: row.lastAccessedAt?.toISOString() ?? null,
     access_count: row.accessCount ?? 0,
     created_at: row.createdAt?.toISOString() ?? (/* @__PURE__ */ new Date()).toISOString(),
@@ -20051,19 +20087,29 @@ function keywordOrderBy(sort) {
 }
 async function keywordSearch(db, query, filters, sort = "importance") {
   const { entityId, agentId, skillTags, category, limit } = filters;
-  const words = query.replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 2).slice(0, 8);
+  const orTerms = query.replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 2).slice(0, 8).map((w) => w.replace(/[^a-zA-Z0-9]/g, "")).filter((w) => w.length > 0);
   const conditions = buildWhereConditions({ entityId, agentId, skillTags, category });
   const orderBy = keywordOrderBy(sort);
-  if (words.length > 0) {
-    const ilikeConditions = words.map((w) => ilike2(agentMemory.fact, `%${w}%`));
-    const rows2 = await db.select().from(agentMemory).where(and3(...conditions, or3(...ilikeConditions))).orderBy(...orderBy).limit(limit);
+  if (orTerms.length > 0) {
+    const tsv = sql18`"agent_memory"."search_tsv"`;
+    const tsq = sql18`to_tsquery('english', ${orTerms.join(" | ")})`;
+    const rows2 = await db.select().from(agentMemory).where(and3(...conditions, sql18`${tsv} @@ ${tsq}`)).orderBy(sql18`ts_rank(${tsv}, ${tsq}) DESC`, ...orderBy).limit(limit);
     return rows2;
   }
   const rows = await db.select().from(agentMemory).where(and3(...conditions)).orderBy(...orderBy).limit(limit);
   return rows;
 }
 async function keywordSearchMemories(db, opts) {
-  const { query, entityId, agentId, skillTags, category, limit = 10, sort = "importance" } = opts;
+  const {
+    query,
+    entityId,
+    agentId,
+    skillTags,
+    category,
+    limit = 10,
+    sort = "importance",
+    touch = true
+  } = opts;
   const rows = await keywordSearch(
     db,
     query,
@@ -20071,7 +20117,7 @@ async function keywordSearchMemories(db, opts) {
     sort
   );
   const memories = rows.map((r) => rowToMemory(r));
-  if (memories.length > 0) {
+  if (touch && memories.length > 0) {
     await touchMemories(
       db,
       memories.map((m) => m.id),
@@ -20143,6 +20189,10 @@ async function loadSource(db, entityId, memoryId) {
   const [row] = await db.select({ source: agentMemory.source }).from(agentMemory).where(and3(eq5(agentMemory.id, memoryId), eq5(agentMemory.entityId, entityId))).limit(1);
   return row ? row.source : void 0;
 }
+async function loadSourceAndLock(db, entityId, memoryId) {
+  const [row] = await db.select({ source: agentMemory.source, importanceLocked: agentMemory.importanceLocked }).from(agentMemory).where(and3(eq5(agentMemory.id, memoryId), eq5(agentMemory.entityId, entityId))).limit(1);
+  return row ? { source: row.source, importanceLocked: row.importanceLocked } : void 0;
+}
 async function archiveAgentMemory(db, entityId, memoryId) {
   const source = await loadSource(db, entityId, memoryId);
   if (source === void 0) return { error: "not_found" };
@@ -20158,6 +20208,17 @@ async function updateAgentMemoryFact(db, entityId, memoryId, fact) {
   await db.update(agentMemory).set({ fact: trimmed, factHash: computeFactHash(trimmed), updatedAt: /* @__PURE__ */ new Date() }).where(and3(eq5(agentMemory.id, memoryId), eq5(agentMemory.entityId, entityId)));
   return { ok: true };
 }
+async function updateAgentMemoryImportance(db, entityId, memoryId, importance) {
+  if (!Number.isInteger(importance) || importance < 1 || importance > 5) {
+    return { error: "invalid_importance" };
+  }
+  const row = await loadSourceAndLock(db, entityId, memoryId);
+  if (row === void 0) return { error: "not_found" };
+  if (row.source === "manual") return { error: "not_agent_memory" };
+  if (row.importanceLocked) return { error: "importance_locked" };
+  await db.update(agentMemory).set({ importance, updatedAt: /* @__PURE__ */ new Date() }).where(and3(eq5(agentMemory.id, memoryId), eq5(agentMemory.entityId, entityId)));
+  return { ok: true };
+}
 
 // ../../packages/memory/src/inject.ts
 var RENDER_OVERHEAD_PER_ENTRY = 20;
@@ -20303,9 +20364,13 @@ function selectMemoriesUnderBudget(memories, maxChars, query) {
     if (aTouched !== bTouched) return bTouched.localeCompare(aTouched);
     return a.id.localeCompare(b.id);
   });
+  return packUnderBudget(sorted, maxChars);
+}
+function packUnderBudget(memories, maxChars) {
+  if (maxChars <= 0) return [];
   const picked = [];
   let used = 0;
-  for (const m of sorted) {
+  for (const m of memories) {
     const cost = m.fact.length + RENDER_OVERHEAD_PER_ENTRY;
     if (used + cost > maxChars) continue;
     picked.push(m);
@@ -20316,13 +20381,25 @@ function selectMemoriesUnderBudget(memories, maxChars, query) {
 var MAX_CANDIDATES = 200;
 async function selectMemoriesForInjection(db, opts) {
   if (opts.maxChars <= 0) return [];
-  const candidates = await db.select().from(agentMemory).where(
-    and3(
-      eq5(agentMemory.entityId, opts.entityId),
-      eq5(agentMemory.archived, false),
-      sql18`(${agentMemory.validTo} IS NULL OR ${agentMemory.validTo} > now())`
-    )
-  ).orderBy(desc(agentMemory.importance), desc(agentMemory.lastAccessedAt)).limit(MAX_CANDIDATES);
+  const baseConditions = and3(
+    eq5(agentMemory.entityId, opts.entityId),
+    eq5(agentMemory.archived, false),
+    sql18`(${agentMemory.validTo} IS NULL OR ${agentMemory.validTo} > now())`
+  );
+  const rawQuery = opts.query ?? "";
+  const tokens = tokenizeQuery(rawQuery);
+  if (tokens.length > 0) {
+    const tsv = sql18`"agent_memory"."search_tsv"`;
+    const tsq = sql18`plainto_tsquery('english', ${rawQuery})`;
+    const candidates2 = await db.select().from(agentMemory).where(baseConditions).orderBy(
+      sql18`ts_rank(${tsv}, ${tsq}) DESC`,
+      desc(agentMemory.importance),
+      desc(agentMemory.lastAccessedAt)
+    ).limit(MAX_CANDIDATES);
+    const memories2 = candidates2.map((row) => rowToMemory(row));
+    return packUnderBudget(memories2, opts.maxChars);
+  }
+  const candidates = await db.select().from(agentMemory).where(baseConditions).orderBy(desc(agentMemory.importance), desc(agentMemory.lastAccessedAt)).limit(MAX_CANDIDATES);
   const memories = candidates.map((row) => rowToMemory(row));
   return selectMemoriesUnderBudget(memories, opts.maxChars, opts.query);
 }
@@ -44595,10 +44672,15 @@ var EditMemoryArgs = z113.object({
 var ArchiveMemoryArgs = z113.object({
   memoryId: z113.string().uuid("memoryId must be a valid UUID.")
 });
+var SetImportanceArgs = z113.object({
+  memoryId: z113.string().uuid("memoryId must be a valid UUID."),
+  importance: z113.number().int().min(1).max(5),
+  reason: z113.string().min(1).max(200)
+});
 function buildSystemPrompt2(candidateList) {
   return `You are the MEMORY CURATOR for this entity. Your job is to keep the durable-fact memory SMALL, DENSE, and NON-REDUNDANT, so the limited injection budget is spent on signal.
 
-CANDIDATE FACTS (id, source, importance, length, text):
+CANDIDATE FACTS (id, source, importance, access_count, length, text):
 ${candidateList}
 
 WHAT A GOOD FACT IS: ONE short, durable statement (a preference, an ID, a convention, a learned rule) \u2014 typically under ${HEALTHY_FACT_CHARS} characters. NOT a document, a raw dump, or a session log.
@@ -44607,12 +44689,14 @@ ACTIONS:
 1. DISTILL oversized facts \u2014 if a fact is a big blob (a pasted workflow/JSON, a long log, a transcript), call edit_memory to replace it with just the key statement + a pointer to where the artifact actually lives (e.g. "... saved in workspace file workflows/X.json"). Keep the SIGNAL, drop the bulk.
 2. MERGE near-duplicates \u2014 when several facts say the same thing, edit_memory ONE of them to the best consolidated wording, then archive_memory the others.
 3. ARCHIVE the clearly obsolete or contradictory.
+4. RE-SCORE importance \u2014 a fact's initial importance is just the authoring agent's one-shot estimate. access_count is PROVEN usage, and it is more reliable than that estimate. Call set_importance to RAISE the importance of a durable fact that is accessed often (it clearly matters), and to LOWER the importance of a fact that has never been used despite being around a while (it probably doesn't). Give a short reason.
 
 HARD RULES:
-- You may ONLY edit/archive AGENT-authored facts. The tools REFUSE source='manual' (user-entered) \u2014 do NOT attempt them, and do not retry a refused call.
+- You may ONLY edit/archive/re-score AGENT-authored facts. The tools REFUSE source='manual' (user-entered) \u2014 do NOT attempt them, and do not retry a refused call.
 - Archiving is the maximum action \u2014 it is reversible; never invent or fabricate facts.
 - When a fact is already a clean short statement, LEAVE IT. A no-op pass is correct and common on a tidy pool.
-- Do NOT merge facts that are merely related but distinct \u2014 only true duplicates.`;
+- Do NOT merge facts that are merely related but distinct \u2014 only true duplicates.
+- Do NOT re-score every fact out of habit \u2014 only when access_count clearly disagrees with the current importance.`;
 }
 function renderCandidates(facts) {
   if (facts.length === 0) return "(none)";
@@ -44620,7 +44704,7 @@ function renderCandidates(facts) {
     const len = f.fact.length;
     const oversized = len > HEALTHY_FACT_CHARS ? " OVERSIZED" : "";
     const text22 = len > 200 ? `${f.fact.slice(0, 200)}\u2026` : f.fact;
-    return `- id=${f.id} source=${f.source ?? "agent"} importance=${f.importance ?? 3} len=${len}${oversized}
+    return `- id=${f.id} source=${f.source ?? "agent"} importance=${f.importance ?? 3} access_count=${f.accessCount ?? 0} len=${len}${oversized}
     ${text22.replace(/\s+/g, " ")}`;
   }).join("\n");
 }
@@ -44629,9 +44713,10 @@ async function runMemoryCuration(db, entityId, maxTurns, reflectionModel) {
     id: agentMemory.id,
     fact: agentMemory.fact,
     source: agentMemory.source,
-    importance: agentMemory.importance
+    importance: agentMemory.importance,
+    accessCount: agentMemory.accessCount
   }).from(agentMemory).where(and3(eq5(agentMemory.entityId, entityId), eq5(agentMemory.archived, false))).limit(MAX_CANDIDATES2);
-  if (candidates.length === 0) return { edited: 0, archived: 0, turns: 0 };
+  if (candidates.length === 0) return { edited: 0, archived: 0, rescored: 0, turns: 0 };
   const agentRows = await db.select({
     llmKeyId: agents.llmKeyId,
     fallbackChain: agents.fallbackChain,
@@ -44654,7 +44739,7 @@ async function runMemoryCuration(db, entityId, maxTurns, reflectionModel) {
   }
   if (!resolved?.ok) {
     console.warn(`${TRACE} no LLM client for entity ${entityId}, skipping`);
-    return { edited: 0, archived: 0, turns: 0 };
+    return { edited: 0, archived: 0, rescored: 0, turns: 0 };
   }
   const llmClient = resolved.client;
   const systemPrompt = buildSystemPrompt2(renderCandidates(candidates));
@@ -44672,10 +44757,15 @@ async function runMemoryCuration(db, entityId, maxTurns, reflectionModel) {
     archive_memory: {
       description: "Soft-archive a redundant/obsolete agent-authored fact (reversible). Provide the memory UUID. Refuses user-entered (manual) facts.",
       inputSchema: ArchiveMemoryArgs
+    },
+    set_importance: {
+      description: "Re-score a fact's importance (1-5) from REAL usage (access_count) + relevance. Raise for frequently-accessed durable facts; lower for never-used ones. Refuses user-entered (manual) facts.",
+      inputSchema: SetImportanceArgs
     }
   };
   let edited = 0;
   let archived = 0;
+  let rescored = 0;
   let turns = 0;
   console.warn(`${TRACE} start`, { entityId, candidateCount: candidates.length });
   for (let turn = 0; turn < maxTurns; turn += 1) {
@@ -44733,6 +44823,24 @@ async function runMemoryCuration(db, entityId, maxTurns, reflectionModel) {
             outcome = `archived memory ${parsed.data.memoryId}`;
           }
         }
+      } else if (tc.toolName === "set_importance") {
+        const parsed = SetImportanceArgs.safeParse(tc.input);
+        if (!parsed.success) {
+          outcome = `error: invalid_input: ${parsed.error.message}`;
+        } else {
+          const res = await updateAgentMemoryImportance(
+            db,
+            entityId,
+            parsed.data.memoryId,
+            parsed.data.importance
+          );
+          if ("error" in res) {
+            outcome = res.error === "not_agent_memory" ? `error: memory ${parsed.data.memoryId} is user-entered and cannot be re-scored by the curator.` : res.error === "invalid_importance" ? `error: importance must be an integer 1-5.` : res.error === "importance_locked" ? `error: memory ${parsed.data.memoryId} importance is user-locked and cannot be re-scored.` : `error: memory ${parsed.data.memoryId} not found in this entity.`;
+          } else {
+            rescored += 1;
+            outcome = `set importance of memory ${parsed.data.memoryId} to ${parsed.data.importance} (${parsed.data.reason})`;
+          }
+        }
       } else {
         outcome = `error: unknown tool ${tc.toolName}`;
       }
@@ -44745,8 +44853,8 @@ async function runMemoryCuration(db, entityId, maxTurns, reflectionModel) {
     }
     messages.push({ role: "tool", content: resultParts });
   }
-  console.warn(`${TRACE} done`, { entityId, edited, archived, turns });
-  return { edited, archived, turns };
+  console.warn(`${TRACE} done`, { entityId, edited, archived, rescored, turns });
+  return { edited, archived, rescored, turns };
 }
 
 // src/cron/run-curator.ts
@@ -44761,6 +44869,11 @@ var SAFE_LIFECYCLE_DEFAULTS = {
   CURATOR_MEMORY_IMPORTANCE_MAX: 2,
   CURATOR_MEMORY_MIN: 8,
   REFLECTION_ENABLED: "false",
+  // Conservative fallback for environments without DATABASE_URL (test envs) —
+  // mirrors REFLECTION_ENABLED's safe default. The REAL production default
+  // (per-entity decides, ON since entities.memory_curation_enabled defaults
+  // true) comes from the zod schema in env.ts, not from this fallback.
+  MEMORY_CURATION_ENABLED: "false",
   REFLECTION_MODEL: void 0
 };
 function resolveCuratorEnv(runnerEnv) {
@@ -44777,6 +44890,7 @@ function resolveCuratorEnv(runnerEnv) {
       CURATOR_MEMORY_IMPORTANCE_MAX: env.CURATOR_MEMORY_IMPORTANCE_MAX,
       CURATOR_MEMORY_MIN: env.CURATOR_MEMORY_MIN,
       REFLECTION_ENABLED: env.REFLECTION_ENABLED,
+      MEMORY_CURATION_ENABLED: env.MEMORY_CURATION_ENABLED,
       REFLECTION_MODEL: env.REFLECTION_MODEL
     };
   } catch {
@@ -44793,7 +44907,26 @@ async function runCuratorTick(db, _deps, runnerEnv) {
     staleDays: e.CURATOR_MEMORY_STALE_DAYS,
     importanceMax: e.CURATOR_MEMORY_IMPORTANCE_MAX
   });
-  if (e.REFLECTION_ENABLED === "false") {
+  const intervalMs = e.CURATOR_INTERVAL_DAYS * 24 * 60 * 60 * 1e3;
+  const intervalCutoff = new Date(Date.now() - intervalMs);
+  const now = /* @__PURE__ */ new Date();
+  const skillSet = /* @__PURE__ */ new Set();
+  if (e.REFLECTION_ENABLED !== "false") {
+    const skillCandidates = await db.select({ entityId: agentSkills.entityId }).from(agentSkills).innerJoin(entities, eq5(entities.id, agentSkills.entityId)).where(
+      and3(
+        eq5(agentSkills.createdBy, "agent"),
+        eq5(agentSkills.state, "active"),
+        eq5(entities.reflectionEnabled, true)
+      )
+    ).groupBy(agentSkills.entityId).having(sql18`count(${agentSkills.id}) >= ${e.CURATOR_MIN_SKILLS}`);
+    for (const c of skillCandidates) if (c.entityId) skillSet.add(c.entityId);
+  }
+  const memorySet = /* @__PURE__ */ new Set();
+  if (e.MEMORY_CURATION_ENABLED !== "false") {
+    const memoryCandidates = await db.select({ entityId: agentMemory.entityId }).from(agentMemory).innerJoin(entities, eq5(entities.id, agentMemory.entityId)).where(and3(eq5(agentMemory.archived, false), eq5(entities.memoryCurationEnabled, true))).groupBy(agentMemory.entityId).having(sql18`count(${agentMemory.id}) >= ${e.CURATOR_MEMORY_MIN}`);
+    for (const c of memoryCandidates) if (c.entityId) memorySet.add(c.entityId);
+  }
+  if (skillSet.size === 0 && memorySet.size === 0) {
     return {
       staled: lifecycle.staled,
       archived: lifecycle.archived,
@@ -44804,21 +44937,6 @@ async function runCuratorTick(db, _deps, runnerEnv) {
       memoryCurationRan: 0
     };
   }
-  const intervalMs = e.CURATOR_INTERVAL_DAYS * 24 * 60 * 60 * 1e3;
-  const intervalCutoff = new Date(Date.now() - intervalMs);
-  const now = /* @__PURE__ */ new Date();
-  const skillCandidates = await db.select({ entityId: agentSkills.entityId }).from(agentSkills).innerJoin(entities, eq5(entities.id, agentSkills.entityId)).where(
-    and3(
-      eq5(agentSkills.createdBy, "agent"),
-      eq5(agentSkills.state, "active"),
-      eq5(entities.reflectionEnabled, true)
-    )
-  ).groupBy(agentSkills.entityId).having(sql18`count(${agentSkills.id}) >= ${e.CURATOR_MIN_SKILLS}`);
-  const memoryCandidates = await db.select({ entityId: agentMemory.entityId }).from(agentMemory).innerJoin(entities, eq5(entities.id, agentMemory.entityId)).where(and3(eq5(agentMemory.archived, false), eq5(entities.reflectionEnabled, true))).groupBy(agentMemory.entityId).having(sql18`count(${agentMemory.id}) >= ${e.CURATOR_MEMORY_MIN}`);
-  const skillSet = /* @__PURE__ */ new Set();
-  for (const c of skillCandidates) if (c.entityId) skillSet.add(c.entityId);
-  const memorySet = /* @__PURE__ */ new Set();
-  for (const c of memoryCandidates) if (c.entityId) memorySet.add(c.entityId);
   let consolidationDeferred = 0;
   let consolidationRan = 0;
   let memoryCurationRan = 0;

package/web/.next/BUILD_ID

@@ -1 +1 @@
-RORb5LJdSgtd7i6KVr0zl
+KFac7DQ7gdp9XPQ2bnb-2

package/web/.next/app-path-routes-manifest.json

@@ -12,8 +12,8 @@
   "/(dashboard)/agents/[id]/edit/page": "/agents/[id]/edit",
   "/(dashboard)/agents/[id]/telegram/page": "/agents/[id]/telegram",
   "/(dashboard)/agents/page": "/agents",
-  "/(dashboard)/approvals/page": "/approvals",
   "/(dashboard)/automations/page": "/automations",
+  "/(dashboard)/approvals/page": "/approvals",
   "/(dashboard)/chat/page": "/chat",
   "/(dashboard)/connectors/page": "/connectors",
   "/(dashboard)/credentials/page": "/credentials",
@@ -25,8 +25,8 @@
   "/(dashboard)/mcp/page": "/mcp",
   "/(dashboard)/memories/page": "/memories",
   "/(dashboard)/settings/page": "/settings",
-  "/(dashboard)/page": "/",
   "/(dashboard)/settings/root-context/page": "/settings/root-context",
+  "/(dashboard)/page": "/",
   "/(dashboard)/skills/[id]/edit/page": "/skills/[id]/edit",
   "/(dashboard)/skills/page": "/skills"
 }

package/web/.next/build-manifest.json

@@ -4,8 +4,8 @@
   ],
   "devFiles": [],
   "lowPriorityFiles": [
-    "static/RORb5LJdSgtd7i6KVr0zl/_buildManifest.js",
-    "static/RORb5LJdSgtd7i6KVr0zl/_ssgManifest.js"
+    "static/KFac7DQ7gdp9XPQ2bnb-2/_buildManifest.js",
+    "static/KFac7DQ7gdp9XPQ2bnb-2/_ssgManifest.js"
   ],
   "rootMainFiles": [
     "static/chunks/webpack-3741bf0a7636d65e.js",

package/web/.next/prerender-manifest.json

@@ -54,8 +54,8 @@
   "dynamicRoutes": {},
   "notFoundRoutes": [],
   "preview": {
-    "previewModeId": "0fe1567311ac81058123d2fb29f471aa",
-    "previewModeSigningKey": "d42bb4f2e429384a32bfb655168a3f79da18f56daff5a3f3f76ee18b63cb0a44",
-    "previewModeEncryptionKey": "ba9fd61dfd6daabaa848e4ac8b5f2a9e61c371b568524018b3fbe46345657779"
+    "previewModeId": "9ca9c6c94be2ac6b133cc8186cc3e575",
+    "previewModeSigningKey": "e0be6b0a50047a39c91cb1f3c0c956afeeca98f59c75c182395022d820c862a6",
+    "previewModeEncryptionKey": "8eb9a91dc33886853caf249132d193b1db18b4ad8b66413c2343f5f4a4c31d37"
   }
 }