nodal-agents 0.6.7 → 0.7.0

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
@@ -19575,13 +19610,6 @@ var WhitelistDriftError = class extends Error {
   undeclaredTools;
   code = "whitelist_drift";
 };
-var WebSearchNotConfiguredError = class extends Error {
-  code = "web_search_not_configured";
-  constructor() {
-    super("web_search_not_configured");
-    this.name = "WebSearchNotConfiguredError";
-  }
-};
 
 // ../../packages/tools/src/registry.ts
 function createToolRegistry() {
@@ -20033,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(),
@@ -20058,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,
@@ -20078,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),
@@ -20150,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" };
@@ -20165,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;
@@ -20310,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);
@@ -20323,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);
 }
@@ -20584,17 +20654,80 @@ import { z as z25 } from "zod";
 var WebSearchInputSchema = z25.object({
   query: z25.string().min(1).describe("The search query.")
 });
+var DEGRADED_GUIDANCE = "Free best-effort web search failed (it can be rate-limited or blocked). For reliable results, add a Tavily key (free tier) in the dashboard under Connectors, and I'll use it automatically.";
+var DDG_ENDPOINT = "https://html.duckduckgo.com/html/";
+function stripHtml(html) {
+  return html.replace(/<[^>]*>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#x27;/g, "'").replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim();
+}
+function resolveDdgHref(href) {
+  const normalized = href.startsWith("//") ? `https:${href}` : href;
+  const uddg = normalized.match(/[?&]uddg=([^&]+)/);
+  if (uddg?.[1]) {
+    try {
+      return decodeURIComponent(uddg[1]);
+    } catch {
+    }
+  }
+  return normalized;
+}
+function parseDuckDuckGoHtml(html) {
+  const results = [];
+  const anchorRe = /<a[^>]*class="[^"]*result__a[^"]*"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+  const snippetRe = /<a[^>]*class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/a>/gi;
+  let match;
+  while ((match = anchorRe.exec(html)) !== null) {
+    const href = match[1];
+    const rawTitle = match[2];
+    if (!href || rawTitle === void 0) continue;
+    const title = stripHtml(rawTitle);
+    const url2 = resolveDdgHref(href);
+    if (!title || !url2) continue;
+    snippetRe.lastIndex = anchorRe.lastIndex;
+    const snippetMatch = snippetRe.exec(html);
+    const snippet = snippetMatch?.[1] ? stripHtml(snippetMatch[1]) : "";
+    results.push({ title, url: url2, snippet });
+  }
+  return results;
+}
+async function duckDuckGoSearch(query) {
+  let html;
+  try {
+    const res = await fetch(DDG_ENDPOINT, {
+      // The html endpoint blocks GET (returns 202 with an empty challenge page)
+      // but serves 200 + real results for a form POST. A browser-ish UA is also
+      // required (bare requests are refused).
+      method: "POST",
+      headers: {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0 Safari/537.36",
+        Accept: "text/html",
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: "q=" + encodeURIComponent(query)
+    });
+    if (!res.ok) {
+      return { results: [], degraded: true, guidance: DEGRADED_GUIDANCE };
+    }
+    html = await res.text();
+  } catch {
+    return { results: [], degraded: true, guidance: DEGRADED_GUIDANCE };
+  }
+  const results = parseDuckDuckGoHtml(html);
+  if (results.length === 0) {
+    return { results: [], degraded: true, guidance: DEGRADED_GUIDANCE };
+  }
+  return { results };
+}
 var webSearchTool = {
   name: "web_search",
-  description: "Search the web for current information. Use when you need up-to-date data, news, or any facts you are not sure about.",
+  description: "Search the web. Uses your configured Tavily/Firecrawl provider if any, otherwise a free best-effort search.",
   inputSchema: WebSearchInputSchema,
   riskLevel: "read",
-  execute: async (_input, _ctx) => {
-    const searchUrl = process.env["NODALAI_WEB_SEARCH_URL"];
-    if (!searchUrl) {
-      throw new WebSearchNotConfiguredError();
+  execute: async (input, ctx) => {
+    if (ctx.searchBackend) {
+      const { results } = await ctx.searchBackend(input.query);
+      return { results };
     }
-    throw new WebSearchNotConfiguredError();
+    return duckDuckGoSearch(input.query);
   }
 };
 
@@ -23519,6 +23652,7 @@ var ALWAYS_ON_TOOLS = [
   "search_history",
   "mark_memory_helpful",
   "mark_memory_outdated",
+  "web_search",
   "dashboard_publish",
   "file_read",
   "file_write",
@@ -23536,6 +23670,7 @@ var ALWAYS_ON_TOOL_DOCS = [
   { name: searchHistoryTool.name, description: searchHistoryTool.description },
   { name: markMemoryHelpfulTool.name, description: markMemoryHelpfulTool.description },
   { name: markMemoryOutdatedTool.name, description: markMemoryOutdatedTool.description },
+  { name: webSearchTool.name, description: webSearchTool.description },
   { name: dashboardPublishTool.name, description: dashboardPublishTool.description },
   { name: fileReadTool.name, description: fileReadTool.description },
   { name: fileWriteTool.name, description: fileWriteTool.description },
@@ -27325,7 +27460,7 @@ function decodeBase64Url(encoded) {
     return "";
   }
 }
-function stripHtml(html) {
+function stripHtml2(html) {
   return html.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<[^>]+>/g, " ").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#39;/gi, "'").replace(/[ \t]+/g, " ").replace(/\n\s*\n\s*\n/g, "\n\n").trim();
 }
 function decodePartBody(part) {
@@ -27340,7 +27475,7 @@ function extractTextFromPayload(payload) {
     return decodePartBody(payload);
   }
   if (mime.startsWith("text/html")) {
-    return stripHtml(decodePartBody(payload));
+    return stripHtml2(decodePartBody(payload));
   }
   if (mime.startsWith("multipart/")) {
     const parts = payload.parts ?? [];
@@ -42081,6 +42216,44 @@ var TOOL_PROVISIONING = {
   },
   encrypt
 };
+async function resolveSearchBackend(db, agentId) {
+  const rows = await db.select({
+    slug: connectors.slug,
+    apiKey: connectors.apiKey
+  }).from(agentConnectorAssignments).innerJoin(connectors, eq5(connectors.id, agentConnectorAssignments.connectorId)).where(eq5(agentConnectorAssignments.agentId, agentId));
+  for (const slug of ["tavily", "firecrawl"]) {
+    const row = rows.find((r) => r.slug === slug);
+    if (!row?.apiKey) continue;
+    let key;
+    try {
+      key = decrypt(row.apiKey);
+    } catch {
+      continue;
+    }
+    const entry = ADAPTER_REGISTRY[slug];
+    if (!entry) continue;
+    const toolName = slug === "tavily" ? "tavily_search" : "firecrawl_search";
+    const searchTool = entry.toolFactory(key).find((t) => t.name === toolName);
+    if (!searchTool) continue;
+    return async (query) => {
+      const out = await searchTool.execute({ query }, {
+        jobId: "",
+        agentId,
+        entityId: "",
+        db,
+        jobChatId: null
+      });
+      const results = (out.results ?? []).map((r) => ({
+        title: r.title ?? "",
+        url: r.url ?? "",
+        // Tavily → `content`; Firecrawl → `description`.
+        snippet: r.content ?? r.description ?? ""
+      }));
+      return { results };
+    };
+  }
+  return void 0;
+}
 var DELIVERY_TOOL_NAMES = /* @__PURE__ */ new Set([
   "telegram_send_message",
   "send_image",
@@ -42328,6 +42501,7 @@ async function runJob(jobId, deps, runnerEnv, opts) {
   const scriptAuthorizedSkillSlugs = assignedSkillRows.filter((r) => r.scriptsAuthorized).map((r) => r.slug);
   const fileWritableSkillSlugs = assignedSkillRows.filter((r) => r.filesWritable).map((r) => r.slug);
   const skillStore = skillStoreDir(job.entityId);
+  const searchBackend = await resolveSearchBackend(db, agentRow.id);
   if (!agentRow.llmKeyId) {
     await failJob(db, jobId, "agent_no_llm_configured", runStats(), messages);
     return { status: "failed", error: "agent_no_llm_configured" };
@@ -42647,7 +42821,8 @@ async function runJob(jobId, deps, runnerEnv, opts) {
                 assignedSkillSlugs,
                 scriptAuthorizedSkillSlugs,
                 fileWritableSkillSlugs,
-                provisioning: TOOL_PROVISIONING
+                provisioning: TOOL_PROVISIONING,
+                searchBackend
               },
               {
                 approvalRules: resumeApprovalRules,
@@ -43059,7 +43234,8 @@ async function runJob(jobId, deps, runnerEnv, opts) {
         assignedSkillSlugs,
         scriptAuthorizedSkillSlugs,
         fileWritableSkillSlugs,
-        provisioning: TOOL_PROVISIONING
+        provisioning: TOOL_PROVISIONING,
+        searchBackend
       };
       const sharedToolOpts = {
         approvalRules: approvalRuleList,
@@ -43190,7 +43366,8 @@ async function runJob(jobId, deps, runnerEnv, opts) {
                 assignedSkillSlugs,
                 scriptAuthorizedSkillSlugs,
                 fileWritableSkillSlugs,
-                provisioning: TOOL_PROVISIONING
+                provisioning: TOOL_PROVISIONING,
+                searchBackend
               },
               {
                 approvalRules: approvalRuleList,
@@ -44495,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.
@@ -44507,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)";
@@ -44520,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");
 }
@@ -44529,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,
@@ -44554,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));
@@ -44572,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) {
@@ -44633,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}`;
       }
@@ -44645,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
@@ -44661,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) {
@@ -44677,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 {
@@ -44693,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,
@@ -44704,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 @@
-vB-0ke6pDH6vYyme7Pz5G
+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",
@@ -24,9 +24,9 @@
   "/(dashboard)/logs/page": "/logs",
   "/(dashboard)/mcp/page": "/mcp",
   "/(dashboard)/memories/page": "/memories",
+  "/(dashboard)/settings/page": "/settings",
   "/(dashboard)/settings/root-context/page": "/settings/root-context",
   "/(dashboard)/page": "/",
-  "/(dashboard)/settings/page": "/settings",
   "/(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/vB-0ke6pDH6vYyme7Pz5G/_buildManifest.js",
-    "static/vB-0ke6pDH6vYyme7Pz5G/_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": "3ddad284aca041171a552f29c79b2200",
-    "previewModeSigningKey": "f2ff4ccd9469bedec6018f452f10feb96216a89db18329912414b8fc3c4cb1af",
-    "previewModeEncryptionKey": "9a716beb1723a56c4e5ebee6c2b7f7efc7dad2855ea8eca4ff499e88c104f0c1"
+    "previewModeId": "9ca9c6c94be2ac6b133cc8186cc3e575",
+    "previewModeSigningKey": "e0be6b0a50047a39c91cb1f3c0c956afeeca98f59c75c182395022d820c862a6",
+    "previewModeEncryptionKey": "8eb9a91dc33886853caf249132d193b1db18b4ad8b66413c2343f5f4a4c31d37"
   }
 }