@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/plugins/defaults/memory/job-handler-registration.ts

@@ -0,0 +1,96 @@
+/**
+ * Register the background-job handlers into the worker's dispatch table.
+ *
+ * The memory plugin owns registration end-to-end: its `init` hook (daemon) and
+ * the standalone worker process — the two callers that actually start the
+ * worker — register here rather than routing handlers through a generic plugin
+ * job-handler registry. Keeping registration inside the plugin means the startup
+ * path never has to reach back through the `plugins/defaults` barrel, which would
+ * otherwise close an import cycle.
+ *
+ * This registers the memory plugin's own handlers plus the host's non-plugin
+ * domain handlers (persistence cleanup, message-content lexical indexing,
+ * conversations, media, home, runtime). Those domain handlers — and their daemon
+ * imports below — live here temporarily; they will move to a memory-agnostic
+ * background schedule worker in a future rework, at which point they leave the
+ * memory plugin.
+ *
+ * Idempotent: registering a type twice overwrites with the same handler, so
+ * repeated calls (e.g. the daemon init hook and the standalone worker process)
+ * are safe.
+ */
+
+import { buildConversationSummaryJob } from "../../../conversations/job-handlers/summarization.js";
+import { generateConversationStartersJob } from "../../../home/job-handlers/conversation-starters.js";
+import { mediaProcessingJob } from "../../../media/job-handlers/media-processing.js";
+import {
+  pruneOldConversationsJob,
+  pruneOldLlmRequestLogsJob,
+  pruneOldToolInvocationsJob,
+  pruneOldTraceEventsJob,
+} from "../../../persistence/job-handlers/cleanup.js";
+import {
+  deleteMessageLexicalJob,
+  indexMessageLexicalJob,
+  purgeConversationLexicalJob,
+} from "../../../persistence/job-handlers/message-lexical.js";
+import { backfillLexicalIndexJob } from "../../../persistence/job-handlers/message-lexical-backfill.js";
+import { registerJobHandler } from "../../../persistence/jobs-worker.js";
+import { conversationAnalyzeJob } from "../../../runtime/services/conversation-analyze-job.js";
+import { memoryJobHandlers } from "./job-handlers.js";
+
+export function registerMemoryPluginJobHandlers(): void {
+  // The memory plugin's own handlers.
+  for (const { type, handler } of memoryJobHandlers) {
+    registerJobHandler(type, handler);
+  }
+
+  // Non-plugin domain handlers for domains that are not plugins (persistence
+  // cleanup, message-content lexical indexing, conversations, media, home,
+  // runtime). These are host-owned and merely share the background job queue;
+  // they will move to a memory-agnostic background schedule worker soon. Each is
+  // registered behind an arrow that reads the imported binding at dispatch time
+  // rather than capturing it eagerly, so a per-test `mock.module` of the
+  // underlying handler is honored.
+  registerJobHandler("prune_old_conversations", (job, config) =>
+    pruneOldConversationsJob(job, config),
+  );
+  registerJobHandler("index_message_lexical", (job, config) =>
+    indexMessageLexicalJob(job, config),
+  );
+  registerJobHandler("purge_conversation_lexical", (job, config) =>
+    purgeConversationLexicalJob(job, config),
+  );
+  registerJobHandler("delete_message_lexical", (job, config) =>
+    deleteMessageLexicalJob(job, config),
+  );
+  registerJobHandler("backfill_lexical_index", (job, config) =>
+    backfillLexicalIndexJob(job, config),
+  );
+  registerJobHandler("prune_old_llm_request_logs", (job, config) =>
+    pruneOldLlmRequestLogsJob(job, config),
+  );
+  registerJobHandler("prune_old_trace_events", (job, config) =>
+    pruneOldTraceEventsJob(job, config),
+  );
+  registerJobHandler("prune_old_tool_invocations", (job, config) =>
+    pruneOldToolInvocationsJob(job, config),
+  );
+  registerJobHandler("build_conversation_summary", async (job, config) => {
+    // Stale rows enqueued before v2 was enabled must not consume the
+    // `conversationSummarization` LLM budget — v2 readers do not consume
+    // `memorySummaries`, mirroring the `graph_extract` gate in the memory
+    // plugin's job handlers.
+    if (config.memory.v2.enabled) {
+      return;
+    }
+    await buildConversationSummaryJob(job, config);
+  });
+  registerJobHandler("media_processing", (job) => mediaProcessingJob(job));
+  registerJobHandler("conversation_analyze", (job, config) =>
+    conversationAnalyzeJob(job, config),
+  );
+  registerJobHandler("generate_conversation_starters", (job) =>
+    generateConversationStartersJob(job),
+  );
+}

package/src/plugins/defaults/memory/job-handlers/backfill.ts

@@ -6,38 +6,18 @@ import {
   resetMessageCursorCheckpoint,
   writeMessageCursorCheckpoint,
 } from "../../../../persistence/checkpoints.js";
-import { messageMetadataSchema } from "../../../../persistence/conversation-crud.js";
+import { parseMessageMetadata } from "../../../../persistence/conversation-crud.js";
 import { getDb } from "../../../../persistence/db-connection.js";
 import {
   enqueueMemoryJob,
   type MemoryJob,
 } from "../../../../persistence/jobs-store.js";
 import { messages } from "../../../../persistence/schema/index.js";
-import type { TrustClass } from "../../../../runtime/actor-trust-resolver.js";
 import { indexMessageNow } from "../indexer.js";
 
 const BACKFILL_CHECKPOINT_KEY = "memory:backfill:last_created_at";
 const BACKFILL_CHECKPOINT_ID_KEY = "memory:backfill:last_message_id";
 
-function parseMessageMetadata(rawMetadata: string | null): {
-  provenanceTrustClass: TrustClass | undefined;
-  automated: boolean | undefined;
-} {
-  if (!rawMetadata)
-    return { provenanceTrustClass: undefined, automated: undefined };
-  try {
-    const parsed = messageMetadataSchema.safeParse(JSON.parse(rawMetadata));
-    if (!parsed.success)
-      return { provenanceTrustClass: undefined, automated: undefined };
-    return {
-      provenanceTrustClass: parsed.data.provenanceTrustClass,
-      automated: parsed.data.automated,
-    };
-  } catch {
-    return { provenanceTrustClass: undefined, automated: undefined };
-  }
-}
-
 export async function backfillJob(
   job: MemoryJob,
   config: AssistantConfig,
@@ -73,9 +53,7 @@ export async function backfillJob(
 
   if (batch.length > 0) {
     for (const message of batch) {
-      const { provenanceTrustClass, automated } = parseMessageMetadata(
-        message.metadata ?? null,
-      );
+      const meta = parseMessageMetadata(message.metadata ?? null);
       await indexMessageNow(
         {
           messageId: message.id,
@@ -84,8 +62,8 @@ export async function backfillJob(
           content: message.content,
           createdAt: message.createdAt,
           scopeId: "default",
-          provenanceTrustClass,
-          automated,
+          provenanceTrustClass: meta?.provenanceTrustClass,
+          automated: meta?.automated,
         },
         config.memory,
       );

package/src/plugins/defaults/memory/job-handlers/embedding.test.ts

@@ -41,25 +41,12 @@ mock.module("../../../../persistence/job-utils.js", () => ({
 }));
 
 import { resetDbForTesting } from "../../../../__tests__/db-test-helpers.js";
-import { DEFAULT_CONFIG } from "../../../../config/defaults.js";
-import type { AssistantConfig } from "../../../../config/types.js";
 import { getDb } from "../../../../persistence/db-connection.js";
 import { initializeDb } from "../../../../persistence/db-init.js";
 import type { MemoryJob } from "../../../../persistence/jobs-store.js";
 import { mediaAssets } from "../../../../persistence/schema/index.js";
 import { embedMediaJob } from "./embedding.js";
 
-const TEST_CONFIG: AssistantConfig = {
-  ...DEFAULT_CONFIG,
-  memory: {
-    ...DEFAULT_CONFIG.memory,
-    extraction: {
-      ...DEFAULT_CONFIG.memory.extraction,
-      useLLM: false,
-    },
-  },
-};
-
 describe("embedMediaJob", () => {
   // initializeDb runs the full migration chain (hundreds of steps); under
   // parallel CI load it can exceed bun's default 5s hook timeout, so allow more.
@@ -90,12 +77,12 @@ describe("embedMediaJob", () => {
   }
 
   test("skips when assetId is missing", async () => {
-    await embedMediaJob(makeJob({}), TEST_CONFIG);
+    await embedMediaJob(makeJob({}));
     expect(embedAndUpsertCalls).toHaveLength(0);
   });
 
   test("skips when asset is not found", async () => {
-    await embedMediaJob(makeJob({ assetId: "nonexistent" }), TEST_CONFIG);
+    await embedMediaJob(makeJob({ assetId: "nonexistent" }));
     expect(embedAndUpsertCalls).toHaveLength(0);
   });
 
@@ -122,7 +109,7 @@ describe("embedMediaJob", () => {
       })
       .run();
 
-    await embedMediaJob(makeJob({ assetId: "asset-registered" }), TEST_CONFIG);
+    await embedMediaJob(makeJob({ assetId: "asset-registered" }));
     expect(embedAndUpsertCalls).toHaveLength(0);
   });
 
@@ -149,7 +136,7 @@ describe("embedMediaJob", () => {
       })
       .run();
 
-    await embedMediaJob(makeJob({ assetId: "asset-image" }), TEST_CONFIG);
+    await embedMediaJob(makeJob({ assetId: "asset-image" }));
 
     expect(embedAndUpsertCalls).toHaveLength(1);
     const call = embedAndUpsertCalls[0];
@@ -191,7 +178,7 @@ describe("embedMediaJob", () => {
       })
       .run();
 
-    await embedMediaJob(makeJob({ assetId: "asset-audio" }), TEST_CONFIG);
+    await embedMediaJob(makeJob({ assetId: "asset-audio" }));
 
     expect(embedAndUpsertCalls).toHaveLength(1);
     const call = embedAndUpsertCalls[0];
@@ -224,7 +211,7 @@ describe("embedMediaJob", () => {
       })
       .run();
 
-    await embedMediaJob(makeJob({ assetId: "asset-video" }), TEST_CONFIG);
+    await embedMediaJob(makeJob({ assetId: "asset-video" }));
 
     expect(embedAndUpsertCalls).toHaveLength(1);
     const call = embedAndUpsertCalls[0];

package/src/plugins/defaults/memory/job-handlers/embedding.ts

@@ -2,10 +2,9 @@ import { readFile } from "node:fs/promises";
 
 import { eq } from "drizzle-orm";
 
-import type { AssistantConfig } from "../../../../config/types.js";
 import { getDb } from "../../../../persistence/db-connection.js";
 import type { EmbeddingInput } from "../../../../persistence/embeddings/embedding-types.js";
-import { asString, embedAndUpsert } from "../../../../persistence/job-utils.js";
+import { asString } from "../../../../persistence/job-utils.js";
 import type { MemoryJob } from "../../../../persistence/jobs-store.js";
 import { extractMediaBlocks } from "../../../../persistence/message-content.js";
 import {
@@ -14,11 +13,9 @@ import {
   memorySummaries,
   messages,
 } from "../../../../persistence/schema/index.js";
+import { embedAndUpsert } from "../embeddings.js";
 
-export async function embedSegmentJob(
-  job: MemoryJob,
-  config: AssistantConfig,
-): Promise<void> {
+export async function embedSegmentJob(job: MemoryJob): Promise<void> {
   const segmentId = asString(job.payload.segmentId);
   if (!segmentId) return;
   const db = getDb();
@@ -28,7 +25,7 @@ export async function embedSegmentJob(
     .where(eq(memorySegments.id, segmentId))
     .get();
   if (!segment) return;
-  await embedAndUpsert(config, "segment", segment.id, segment.text, {
+  await embedAndUpsert("segment", segment.id, segment.text, {
     conversation_id: segment.conversationId,
     message_id: segment.messageId,
     created_at: segment.createdAt,
@@ -36,10 +33,7 @@ export async function embedSegmentJob(
   });
 }
 
-export async function embedSummaryJob(
-  job: MemoryJob,
-  config: AssistantConfig,
-): Promise<void> {
+export async function embedSummaryJob(job: MemoryJob): Promise<void> {
   const summaryId = asString(job.payload.summaryId);
   if (!summaryId) return;
   const db = getDb();
@@ -50,7 +44,6 @@ export async function embedSummaryJob(
     .get();
   if (!summary) return;
   await embedAndUpsert(
-    config,
     "summary",
     summary.id,
     `[${summary.scope}] ${summary.summary}`,
@@ -63,10 +56,7 @@ export async function embedSummaryJob(
   );
 }
 
-export async function embedMediaJob(
-  job: MemoryJob,
-  config: AssistantConfig,
-): Promise<void> {
+export async function embedMediaJob(job: MemoryJob): Promise<void> {
   const assetId = asString(job.payload.assetId);
   if (!assetId) return;
 
@@ -88,7 +78,7 @@ export async function embedMediaJob(
     mimeType: asset.mimeType,
   };
 
-  await embedAndUpsert(config, "media", asset.id, input, {
+  await embedAndUpsert("media", asset.id, input, {
     created_at: asset.createdAt,
     kind: asset.mediaType,
     subject: asset.title,
@@ -96,10 +86,7 @@ export async function embedMediaJob(
   });
 }
 
-export async function embedAttachmentJob(
-  job: MemoryJob,
-  config: AssistantConfig,
-): Promise<void> {
+export async function embedAttachmentJob(job: MemoryJob): Promise<void> {
   const messageId = asString(job.payload.messageId);
   const blockIndex = job.payload.blockIndex as number;
   if (!messageId || typeof blockIndex !== "number") return;
@@ -124,7 +111,7 @@ export async function embedAttachmentJob(
 
   // Use messageId + blockIndex as targetId for uniqueness
   const targetId = `${messageId}:${blockIndex}`;
-  await embedAndUpsert(config, "media", targetId, input, {
+  await embedAndUpsert("media", targetId, input, {
     created_at: message.createdAt,
     message_id: messageId,
     conversation_id: message.conversationId,

package/src/plugins/defaults/memory/job-handlers/index-maintenance.ts

@@ -1,8 +1,6 @@
 import { eq, isNotNull, like, ne } from "drizzle-orm";
 
-import { getConfig } from "../../../../config/loader.js";
 import { getDb } from "../../../../persistence/db-connection.js";
-import { selectedBackendSupportsMultimodal } from "../../../../persistence/embeddings/embedding-backend.js";
 import { withQdrantBreaker } from "../../../../persistence/embeddings/qdrant-circuit-breaker.js";
 import { getQdrantClient } from "../../../../persistence/embeddings/qdrant-client.js";
 import {
@@ -24,6 +22,7 @@ import {
   messages,
 } from "../../../../persistence/schema/index.js";
 import { getLogger } from "../../../../util/logger.js";
+import { selectedBackendSupportsMultimodal } from "../embeddings.js";
 
 const log = getLogger("memory-jobs-worker");
 
@@ -50,7 +49,7 @@ export async function rebuildIndexJob(): Promise<void> {
   // Re-enqueue multimodal embedding jobs only when the resolved embedding
   // backend supports multimodal inputs. Without this gate, embed_media and
   // embed_attachment jobs would all fail for text-only backends.
-  if (await selectedBackendSupportsMultimodal(getConfig())) {
+  if (await selectedBackendSupportsMultimodal()) {
     const assets = db
       .select({ id: mediaAssets.id })
       .from(mediaAssets)

package/src/plugins/defaults/memory/job-handlers.ts

@@ -3,10 +3,9 @@
  *
  * Each entry pairs a job-queue `type` with the handler that processes it,
  * sourcing the implementation from the memory feature (`src/memory/*`) and the
- * v3 engine (`./v3/`). `defaultMemoryPlugin` exposes this array via its
- * `jobHandlers` field; bootstrap registers it into the global job-handler
- * registry, and the general job worker (`jobs/register-job-handlers.ts`)
- * forwards it into the worker dispatch table.
+ * v3 engine (`./v3/`). The memory plugin registers this array directly into the
+ * worker dispatch table from its `init` hook — see `job-handler-registration.ts`
+ * (and the standalone worker process, which self-registers it).
  *
  * Each handler is wrapped in an arrow that reads the imported binding at
  * dispatch time rather than capturing it eagerly, so a per-test `mock.module` of
@@ -110,17 +109,17 @@ async function graphNarrativeRefineJob(
 }
 
 /**
- * The memory feature's per-job-type handlers, contributed to the general job
- * worker via the `default-memory` plugin's `jobHandlers` field.
+ * The memory feature's per-job-type handlers, registered directly into the
+ * worker dispatch table by the memory plugin's `init` hook.
  */
 export const memoryJobHandlers: readonly JobHandlerEntry[] = [
   {
     type: "embed_segment",
-    handler: (job, config) => embedSegmentJob(job, config),
+    handler: (job) => embedSegmentJob(job),
   },
   {
     type: "embed_summary",
-    handler: (job, config) => embedSummaryJob(job, config),
+    handler: (job) => embedSummaryJob(job),
   },
   { type: "backfill", handler: (job, config) => backfillJob(job, config) },
   { type: "rebuild_index", handler: () => rebuildIndexJob() },
@@ -128,14 +127,14 @@ export const memoryJobHandlers: readonly JobHandlerEntry[] = [
     type: "delete_qdrant_vectors",
     handler: (job) => deleteQdrantVectorsJob(job),
   },
-  { type: "embed_media", handler: (job, config) => embedMediaJob(job, config) },
+  { type: "embed_media", handler: (job) => embedMediaJob(job) },
   {
     type: "embed_attachment",
-    handler: (job, config) => embedAttachmentJob(job, config),
+    handler: (job) => embedAttachmentJob(job),
   },
   {
     type: "embed_graph_node",
-    handler: (job, config) => embedGraphNodeJob(job, config),
+    handler: (job) => embedGraphNodeJob(job),
   },
   {
     type: "embed_pkb_file",
@@ -150,7 +149,9 @@ export const memoryJobHandlers: readonly JobHandlerEntry[] = [
     handler: async (job, config) => {
       // Stale rows enqueued before v2 was enabled (or by any unguarded v1
       // path) must not consume embedding/extraction budget when v2 is on.
-      if (config.memory.v2.enabled) return;
+      if (config.memory.v2.enabled) {
+        return;
+      }
       await graphExtractJob(job, config);
     },
   },

package/src/plugins/defaults/memory/jobs/embed-concept-page.ts

@@ -23,7 +23,6 @@ import { and, eq } from "drizzle-orm";
 import type { AssistantConfig } from "../../../../config/types.js";
 import { getDb } from "../../../../persistence/db-connection.js";
 import {
-  embedWithBackend,
   generateSparseEmbedding,
   getMemoryBackendStatus,
 } from "../../../../persistence/embeddings/embedding-backend.js";
@@ -43,6 +42,7 @@ import { BackendUnavailableError } from "../../../../util/errors.js";
 import { getLogger } from "../../../../util/logger.js";
 import { getWorkspaceDir } from "../../../../util/platform.js";
 import { applyCorrectionIfCalibrated } from "../anisotropy.js";
+import { embedWithBackend } from "../embeddings.js";
 import { readPage } from "../v2/page-store.js";
 import {
   deleteConceptPageEmbedding,

package/src/plugins/defaults/memory/llm-helpers.ts

@@ -0,0 +1,76 @@
+import type {
+  ContentBlock,
+  Message,
+  ProviderResponse,
+  ToolUseContent,
+} from "@vellumai/plugin-api";
+
+/**
+ * Small pure helpers over the LLM request/response types the memory plugin
+ * runs its own inference with (via `getConfiguredProvider`). They live inside
+ * the plugin — rather than importing the host's `providers/*` — so memory
+ * depends only on its own files plus `@vellumai/plugin-api`, the boundary the
+ * plugin model enforces. Every type they touch is exported from the contract.
+ */
+
+/**
+ * Extract the first text block's text from a ProviderResponse.
+ * Returns empty string if no text block is found.
+ */
+export function extractText(response: ProviderResponse): string {
+  const block = response.content.find(
+    (b): b is Extract<ContentBlock, { type: "text" }> => b.type === "text",
+  );
+  return block?.text?.trim() ?? "";
+}
+
+/**
+ * Find the first tool_use block in a ProviderResponse.
+ */
+export function extractToolUse(
+  response: ProviderResponse,
+): ToolUseContent | undefined {
+  return response.content.find(
+    (b): b is ToolUseContent => b.type === "tool_use",
+  );
+}
+
+/**
+ * Build a single user message in the provider Message format.
+ */
+export function userMessage(text: string): Message {
+  return { role: "user", content: [{ type: "text", text }] };
+}
+
+/**
+ * Build a text content block carrying an ephemeral `cache_control` breakpoint
+ * with a 1h TTL, marking a byte-stable prefix the provider KV cache should
+ * persist across calls. The internal `TextContent` type omits the field (only
+ * the Anthropic provider transforms it onto the wire, preserved through
+ * `toAnthropicBlockSafe`), so we reach through a `Record` cast to keep the core
+ * types provider-agnostic. The 1h TTL matches the provider's auto-applied
+ * breakpoints; Haiku models have the `ttl` stripped provider-side.
+ */
+export function cachedTextBlock(text: string): ContentBlock {
+  const block: ContentBlock = { type: "text", text };
+  (block as unknown as Record<string, unknown>).cache_control = {
+    type: "ephemeral",
+    ttl: "1h",
+  };
+  return block;
+}
+
+/**
+ * Function-calling schema handed to the provider as an LLM tool (the shape the
+ * model sees: name, description, input JSON schema). Structurally matches the
+ * host provider wire-spec (`providers/types` → `tools/tool-types` `ToolDefinition`)
+ * so instances stay assignable to `Provider.sendMessage({ tools })`. Kept local
+ * rather than imported from `@vellumai/plugin-api`: the contract's same-named
+ * `ToolDefinition` is the richer, all-optional author-facing tool type, which
+ * doesn't match the all-required wire-spec at the `: ToolDefinition` sites here.
+ */
+export interface ToolDefinition {
+  name: string;
+  description: string;
+  input_schema: object;
+}

package/src/plugins/defaults/memory/memory-retrospective-job.ts

@@ -57,7 +57,6 @@ import {
   type ConversationRow,
   deleteConversation,
   deleteConversationGently,
-  findMostRecentRetrospectiveFor,
   forkConversationForRetrospective,
   getConversation,
   getMessagesAfter,
@@ -73,6 +72,7 @@ import { resolveUserSlug } from "../../../prompts/persona-resolver.js";
 import type { SystemPromptPersonaOverride } from "../../../prompts/system-prompt.js";
 import { wakeAgentForOpportunity } from "../../../runtime/agent-wake.js";
 import { getLogger } from "../../../util/logger.js";
+import { findMostRecentRetrospectiveFor } from "./find-most-recent-retrospective-for.js";
 import {
   MEMORY_RETROSPECTIVE_FORK_SOURCE,
   MEMORY_RETROSPECTIVE_GROUP_ID,
@@ -454,9 +454,10 @@ interface SourceParityPins {
  * stored on the conversation row — the slugs are omitted so the wake keeps
  * today's persona derivation for them.
  *
- * `hasNoClient` — pinned on BOTH the persona override (the prompt's
- * `05-access-preference` section renders different text under the flag) and
- * the tool-context pin, using the live-turn derivation: interactive
+ * `hasNoClient` — pinned on BOTH the persona override (kept for prompt-build
+ * parity; no system-prompt section branches on the flag, so this pin does not
+ * affect prompt output) and the tool-context pin (the live consumer, gating
+ * tool availability), using the live-turn derivation: interactive
  * interfaces run `updateClient(_, false)` (`hasNoClient = false`), while
  * channel-routed and chrome-extension turns stay clientless (`true`) — the
  * exact `isInteractiveInterface` predicate `conversation-routes.ts` /
@@ -951,7 +952,9 @@ When you do capture a procedure:
 
 2. Capture procedure-scoped knowledge alongside the body. Failure modes, gotchas, and cached values you observed in the trace (error signatures and how you recovered, preconditions, IDs/paths/endpoints that held steady) belong in companion files passed via \`scaffold_managed_skill\`'s \`files\` input (for example \`references/failure-modes.md\`), and the SKILL.md body should reference them so a future load surfaces them.
 
-3. Set \`category\` to the single closest-fitting value from this published set (a value outside it gets no Skills-UI bucket, so always pick from the list, never invent one): browsing, calendar, commerce, content, development, email, health, integrations, messaging, productivity, system, voice.
+3. Set \`activation_hints\` to the concrete situations that should trigger this skill later — phrased as the intent you observed in the trace ("user asks to …", "needs to …", "when the goal is …"), NOT the mechanical steps. These become the skill's "Use when" retrieval signal, so a future turn with a matching intent surfaces the skill even when its name doesn't match the request. Give 1–4 short, distinct triggers. Optionally set \`avoid_when\` for situations where the skill should NOT be used.
+
+4. Set \`category\` to the single closest-fitting value from this published set (a value outside it gets no Skills-UI bucket, so always pick from the list, never invent one): browsing, calendar, commerce, content, development, email, health, integrations, messaging, productivity, system, voice.
 
 Ordinary facts still go through \`remember\` (unlinked) exactly as above — skills are for executed, reusable procedures, not for facts.
 `;

package/src/plugins/defaults/memory/memory-retrospective-startup-cleanup.ts

@@ -51,7 +51,6 @@ import {
   sql,
 } from "drizzle-orm";
 
-import { getConfig } from "../../../config/loader.js";
 import { deleteConversation } from "../../../persistence/conversation-crud.js";
 import { getDb, getMemoryDb } from "../../../persistence/db-connection.js";
 import {
@@ -59,6 +58,7 @@ import {
   memoryJobs,
 } from "../../../persistence/schema/index.js";
 import { getLogger } from "../../../util/logger.js";
+import { getMemoryConfig } from "./config.js";
 import { MEMORY_RETROSPECTIVE_SOURCES } from "./memory-retrospective-constants.js";
 import { loadRetrospectiveRunMessages } from "./memory-retrospective-fork-boundary.js";
 
@@ -94,7 +94,7 @@ export function sweepOrphanMemoryRetrospectiveConversations(
   // retained superseded run from a crash orphan. Tradeoff: under this opt-in,
   // genuine crash orphans persist too. That's acceptable — the operator asked
   // for full run history, and an orphan is just one more retained conversation.
-  if (getConfig().memory?.retrospective?.keepSupersededRuns === true) {
+  if (getMemoryConfig()?.retrospective?.keepSupersededRuns === true) {
     return { swept: 0 };
   }
 

package/src/plugins/defaults/memory/memory-v2-concept-frequency.ts

@@ -71,6 +71,7 @@ export async function getConceptFrequencySummary(
   const onDiskSlugsPromise = listPages(workspaceDir);
 
   const aggRows = rawAll<AggRow>(
+    "conceptFreq:summary:agg",
     `SELECT
        json_extract(c.value, '$.slug')   AS slug,
        json_extract(c.value, '$.status') AS status,
@@ -87,6 +88,7 @@ export async function getConceptFrequencySummary(
   );
 
   const logCountRow = rawGet<CountRow>(
+    "conceptFreq:summary:count",
     `SELECT COUNT(*) AS count
        FROM memory_v2_activation_logs
        WHERE (? IS NULL OR conversation_id = ?)