@vellumai/assistant 0.10.9 → 0.10.10-dev.202607162206.d08e98e

package/src/plugins/defaults/memory/graph/store.ts

@@ -883,3 +883,117 @@ export function getNodeEditHistory(
     .limit(limit)
     .all();
 }
+
+// ---------------------------------------------------------------------------
+// Graph stats
+// ---------------------------------------------------------------------------
+
+/** Fidelity counts for active (non-gone) nodes. */
+export interface FidelityBreakdown {
+  vivid: number;
+  clear: number;
+  faded: number;
+  gist: number;
+}
+
+/** Aggregate health snapshot of the memory v2 graph. */
+export interface GraphStats {
+  /** Total active (non-gone) node count. */
+  total: number;
+  /** Node count by MemoryType. */
+  byType: Partial<Record<MemoryType, number>>;
+  /** Node count by fidelity, excluding gone. */
+  byFidelity: FidelityBreakdown;
+  /** Nodes with significance < 0.15 (at risk of decaying away). */
+  atRisk: number;
+  /** Live edge count — both endpoints are non-gone. */
+  edgeCount: number;
+  /** Epoch ms of the oldest active node, or null if the graph is empty. */
+  oldestCreated: number | null;
+  /** Epoch ms of the newest active node, or null if the graph is empty. */
+  newestCreated: number | null;
+  /** Epoch ms of the most recent reinforcement event, or null if none. */
+  lastReinforced: number | null;
+  /** Mean significance across all active nodes (0–1). */
+  avgSignificance: number;
+  /** Up to 5 highest-significance nodes (content, significance, fidelity, type). */
+  topNodes: Array<{
+    content: string;
+    significance: number;
+    fidelity: string;
+    type: string;
+  }>;
+}
+
+/**
+ * Compute a health snapshot of the memory v2 graph in two queries:
+ *   1. A full scan of active nodes (significance DESC) to derive all
+ *      per-node aggregates in one JS pass.
+ *   2. A SQL COUNT of live edges (both endpoints non-gone).
+ *
+ * Callers that only need the summary number can use `countNodes()` instead.
+ */
+export function computeGraphStats(): GraphStats {
+  // Full scan — significance DESC so topNodes is just the first slice.
+  const nodes = queryNodes({ fidelityNot: ["gone"] });
+
+  const byType: Partial<Record<MemoryType, number>> = {};
+  const byFidelity: FidelityBreakdown = {
+    vivid: 0,
+    clear: 0,
+    faded: 0,
+    gist: 0,
+  };
+  let atRisk = 0;
+  let sigSum = 0;
+  let oldestCreated: number | null = null;
+  let newestCreated: number | null = null;
+  let lastReinforced: number | null = null;
+
+  for (const n of nodes) {
+    byType[n.type] = (byType[n.type] ?? 0) + 1;
+    if (n.fidelity !== "gone") {
+      byFidelity[n.fidelity as keyof FidelityBreakdown] += 1;
+    }
+    if (n.significance < 0.15) atRisk++;
+    sigSum += n.significance;
+    if (oldestCreated === null || n.created < oldestCreated)
+      oldestCreated = n.created;
+    if (newestCreated === null || n.created > newestCreated)
+      newestCreated = n.created;
+    if (lastReinforced === null || n.lastReinforced > lastReinforced)
+      lastReinforced = n.lastReinforced;
+  }
+
+  // Live edge count: both endpoints must be non-gone.
+  const db = getDb();
+  const edgeResult = db
+    .select({ count: sql<number>`count(*)` })
+    .from(memoryGraphEdges)
+    .where(
+      and(
+        sql`NOT EXISTS (SELECT 1 FROM ${memoryGraphNodes} WHERE ${memoryGraphNodes.id} = ${memoryGraphEdges.sourceNodeId} AND ${memoryGraphNodes.fidelity} = 'gone')`,
+        sql`NOT EXISTS (SELECT 1 FROM ${memoryGraphNodes} WHERE ${memoryGraphNodes.id} = ${memoryGraphEdges.targetNodeId} AND ${memoryGraphNodes.fidelity} = 'gone')`,
+      ),
+    )
+    .get();
+
+  return {
+    total: nodes.length,
+    byType,
+    byFidelity,
+    atRisk,
+    edgeCount: edgeResult?.count ?? 0,
+    oldestCreated,
+    newestCreated,
+    lastReinforced,
+    avgSignificance: nodes.length > 0 ? sigSum / nodes.length : 0,
+    // nodes is already sorted significance DESC — slice gives the top N.
+    topNodes: nodes.slice(0, 5).map((n) => ({
+      content: n.content,
+      significance: n.significance,
+      fidelity: n.fidelity,
+      type: n.type,
+    })),
+  };
+}

package/src/plugins/defaults/memory/graph/tool-handlers.ts

@@ -14,7 +14,14 @@ import { enqueueMemoryJob } from "../../../../persistence/jobs-store.js";
 import { enqueuePkbIndexJob } from "../jobs/embed-pkb-file.js";
 import { getLogger } from "../logging.js";
 import { getWorkspaceDir } from "../paths.js";
-import { deleteNode, queryNodes, recordNodeEdit, updateNode } from "./store.js";
+import type { GraphStats } from "./store.js";
+import {
+  computeGraphStats,
+  deleteNode,
+  queryNodes,
+  recordNodeEdit,
+  updateNode,
+} from "./store.js";
 
 const log = getLogger("graph-tool-handlers");
 
@@ -429,3 +436,31 @@ export function handleListMemory(
     total: filtered.length,
   };
 }
+
+// ---------------------------------------------------------------------------
+// handleStatsMemory
+// ---------------------------------------------------------------------------
+
+export interface StatsMemoryResult {
+  success: boolean;
+  message: string;
+  stats: GraphStats | null;
+}
+
+export function handleStatsMemory(config: AssistantConfig): StatsMemoryResult {
+  if (!config.memory.v2.enabled) {
+    return {
+      success: false,
+      message: "stats requires memory v2.",
+      stats: null,
+    };
+  }
+  const stats = computeGraphStats();
+  const n = stats.total;
+  const e = stats.edgeCount;
+  return {
+    success: true,
+    message: `${n} active node${n === 1 ? "" : "s"}, ${e} edge${e === 1 ? "" : "s"}.`,
+    stats,
+  };
+}

package/src/plugins/defaults/memory/graph/tools.ts

@@ -62,18 +62,33 @@ export const graphRecallDefinition = {
 const REMEMBER_DESCRIPTION =
   "Remember anything concrete shared in conversation: corrections, plans, decisions, felt moments, names, dates, commitments, preferences. Corrections are the highest priority — call `remember` the same turn the correction lands. You don't have to call this on every turn; a retrospective pass reviews the conversation after each message-count / time interval and saves what you didn't capture. Use judgment: pause and remember when something feels worth marking, not because the volume is required.";
 
+const REMEMBER_CONTENT_DESCRIPTION =
+  "The fact(s) to remember. Pass a single string for one fact, or an array of strings to record several independent facts in one call. When a turn surfaces multiple unrelated facts, pass them all as an array in one call rather than calling `remember` once per fact. Write naturally — a preference, a detail, a commitment, a plan. No need to categorize.";
+
 /**
- * Save a fact to the assistant's knowledge base. The fact is appended to
- * `buffer.md` (immediately available in the next conversation) and the daily
- * archive (permanent date-indexed record). When `memory.v2.enabled` is true,
- * writes go under `memory/`; otherwise they go under `pkb/`. Consolidation
- * of the buffer into longer-form storage runs as a separate periodic job in
- * both modes.
+ * Appended to the `content` description only under the wiki memory model
+ * (memory v2/v3), where the v2/v3 consolidation prompts treat `[[slug]]`
+ * hints as read-first candidates when filing buffer entries. v1/PKB
+ * workspaces have no wiki pages for the hints to reference, and the pkb
+ * filing job has no instruction to interpret or strip the markup, so it
+ * would persist as literal buffer text there.
  */
-export const graphRememberDefinition = {
-  name: "remember",
-  description: REMEMBER_DESCRIPTION,
-  input_schema: {
+export const REMEMBER_PAGE_HINT_GUIDANCE =
+  "When a fact relates to memory pages already in your context, reference the most specific ones inline as [[slug]] wikilinks — consolidation reads hinted pages first when filing the fact, which matters most for corrections (the hint names the page carrying the outdated fact). Hint only pages you have actually seen, and prefer specific pages over broad hubs.";
+
+/**
+ * Build the `remember` input schema. `pageHints` reflects the wiki-memory
+ * (`memory.v2.enabled`) state and appends
+ * {@link REMEMBER_PAGE_HINT_GUIDANCE} to the `content` description. It is a
+ * thunk re-resolved on every read of that description: the registry's
+ * finalized tool shares the returned schema object by reference, so a
+ * runtime config edit is reflected on the next schema serialization without
+ * re-registering the tool.
+ */
+export function buildRememberInputSchema(options: {
+  pageHints: () => boolean;
+}) {
+  return {
     type: "object",
     properties: {
       content: {
@@ -81,8 +96,11 @@ export const graphRememberDefinition = {
           { type: "string" },
           { type: "array", items: { type: "string" }, minItems: 1 },
         ],
-        description:
-          "The fact(s) to remember. Pass a single string for one fact, or an array of strings to record several independent facts in one call. When a turn surfaces multiple unrelated facts, pass them all as an array in one call rather than calling `remember` once per fact. Write naturally — a preference, a detail, a commitment, a plan. No need to categorize.",
+        get description(): string {
+          return options.pageHints()
+            ? `${REMEMBER_CONTENT_DESCRIPTION} ${REMEMBER_PAGE_HINT_GUIDANCE}`
+            : REMEMBER_CONTENT_DESCRIPTION;
+        },
       },
       finish_turn: {
         type: "boolean",
@@ -91,5 +109,21 @@ export const graphRememberDefinition = {
       },
     },
     required: ["content"],
-  },
+  };
+}
+
+/**
+ * Save a fact to the assistant's knowledge base. The fact is appended to
+ * `buffer.md` (immediately available in the next conversation) and the daily
+ * archive (permanent date-indexed record). When `memory.v2.enabled` is true,
+ * writes go under `memory/`; otherwise they go under `pkb/`. Consolidation
+ * of the buffer into longer-form storage runs as a separate periodic job in
+ * both modes. This base definition carries the mode-neutral schema; the
+ * registered tool appends the page-hint guidance on wiki-memory installs via
+ * {@link buildRememberInputSchema}.
+ */
+export const graphRememberDefinition = {
+  name: "remember",
+  description: REMEMBER_DESCRIPTION,
+  input_schema: buildRememberInputSchema({ pageHints: () => false }),
 } satisfies ToolDefinition;

package/src/plugins/defaults/memory/graph-topology/build-memory-graph.ts

@@ -17,7 +17,6 @@
 
 import { isMemoryV3Live } from "../../../../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../../../../config/types.js";
-import { getDb } from "../../../../persistence/db-connection.js";
 import { getWorkspaceDir } from "../paths.js";
 import { getPageIndex, type PageIndexEntry } from "../v2/page-index.js";
 import { readPage, renderPageContent } from "../v2/page-store.js";
@@ -251,28 +250,17 @@ export async function getMemoryGraph(
 
   const workspaceDir = getWorkspaceDir();
   const pageIndex = await getPageIndex(workspaceDir);
-  // Concepts plus functionality (skills / CLI-command capabilities). Feeding the
-  // full set to the edge builders is what lets a concept's `[[skills/foo]]` link
-  // and skill↔concept co-selections resolve to real edges — buildEdgeGraph and
-  // computeLearnedEdgeGraph both drop endpoints outside the set they're given.
-  // Functionality nodes that end up disconnected are pruned in assembleMemoryGraph.
-  const entries = pageIndex.entries;
-
-  // Synthetic rows (skills / CLI commands) carry `modifiedAt: 0` and have no
-  // on-disk page. Keyed by slug (not prefix) so a real user page that happens
-  // to live under a reserved prefix is NOT mistaken for a synthetic one.
-  const syntheticSlugs = new Set(
-    entries.filter((e) => e.modifiedAt <= 0).map((e) => e.slug),
-  );
+  // The Memory graph is the assistant's learned mind: concept pages and the
+  // links between them. Skills and plugins have their own dedicated pages, so
+  // synthetic capability rows (skills / CLI commands, which carry `modifiedAt: 0`)
+  // are excluded here — the map is about what the assistant knows, not what it
+  // can do.
+  const entries = pageIndex.entries.filter((e) => e.modifiedAt > 0);
 
   // Raw (frontmatter + body) page reader, matching the v3 lane build. A read
   // that rejects drops that article's authored/wikilink edges but keeps its
-  // numeric fallbacks. Synthetic capability rows have no page, so short-circuit
-  // their guaranteed-miss read; a real page is read so its links are captured.
+  // numeric fallbacks.
   const pageRaw = async (slug: Slug): Promise<string> => {
-    if (syntheticSlugs.has(slug)) {
-      return "";
-    }
     const page = await readPage(workspaceDir, slug);
     if (!page) {
       throw new Error(`page not found: ${slug}`);
@@ -289,27 +277,20 @@ export async function getMemoryGraph(
   // little extra edge noise) is a fair trade. Floors keep the thresholds sane
   // even when the retrieval config is aggressive or disables the lane.
   const learned = config.memory.v3.learnedEdges;
-  const learnedGraph = computeLearnedEdgeGraph(
-    { db: getDb() },
-    {
-      halfLifeMs: learned.halfLifeDays * DAY_MS,
-      minCount: Math.max(1, learned.minCount * GRAPH_LEARNED_MIN_COUNT_FACTOR),
-      npmiFloor: Math.max(
-        0,
-        learned.npmiFloor * GRAPH_LEARNED_NPMI_FLOOR_FACTOR,
-      ),
-      maxPerPage: Math.max(learned.maxPerPage, GRAPH_LEARNED_MIN_MAX_PER_PAGE),
-      now: Date.now(),
-      windowMs: LEARNED_EDGES_WINDOW_DAYS * DAY_MS,
-      knownSlugs: new Set(entries.map((e) => e.slug)),
-    },
-  );
+  const learnedGraph = computeLearnedEdgeGraph({
+    halfLifeMs: learned.halfLifeDays * DAY_MS,
+    minCount: Math.max(1, learned.minCount * GRAPH_LEARNED_MIN_COUNT_FACTOR),
+    npmiFloor: Math.max(0, learned.npmiFloor * GRAPH_LEARNED_NPMI_FLOOR_FACTOR),
+    maxPerPage: Math.max(learned.maxPerPage, GRAPH_LEARNED_MIN_MAX_PER_PAGE),
+    now: Date.now(),
+    windowMs: LEARNED_EDGES_WINDOW_DAYS * DAY_MS,
+    knownSlugs: new Set(entries.map((e) => e.slug)),
+  });
 
   const assembled = assembleMemoryGraph({
     entries,
     staticAdjacency: staticGraph.adjacency,
     learnedAdjacency: learnedGraph.adjacency,
-    pruneDisconnectedNonConcepts: true,
   });
 
   return { backend: BACKEND_MEMORY_V3, supported: true, ...assembled };

package/src/plugins/defaults/memory/jobs-worker.ts

@@ -665,7 +665,10 @@ function recordCleanupEnqueued(kind: CleanupJobKind, nowMs: number): void {
  * Enqueue periodic cleanup jobs, each on a cadence equal to its own retention
  * window. A job that keeps data for N is re-enqueued at most once per N:
  * pruning that retains LLM logs for 1h runs hourly, pruning that retains
- * conversations for 30d runs every 30d. Each job's throttle is tracked
+ * conversations for 30d runs every 30d. A non-positive window disables its job
+ * (`conversationRetentionDays`/`auditLog.retentionDays` of 0, or
+ * `llmRequestLogRetentionMs` of `null`/0) — a 0 window would otherwise make the
+ * cadence 0 and busy-loop the enqueue. Each job's throttle is tracked
  * independently in cleanup-schedule-state (and persisted via checkpoints so the
  * cadence survives restarts), and enqueue is deduped in jobs-store, so repeated
  * calls remain safe.
@@ -708,8 +711,14 @@ export function maybeEnqueueScheduledCleanupJobs(
     );
   }
 
+  // A retention of `null` or `0` disables LLM-request-log pruning (keep
+  // forever). `0` must be excluded here, not just `null`: the cadence interval
+  // equals the retention window, so `isDue("llm_request_logs", 0)` reduces to
+  // `nowMs - lastEnqueue >= 0` — always true — which would re-enqueue the prune
+  // on every idle/drain tick and spin a sqlite3 subprocess many times a second.
   if (
     cleanup.llmRequestLogRetentionMs !== null &&
+    cleanup.llmRequestLogRetentionMs > 0 &&
     isDue("llm_request_logs", cleanup.llmRequestLogRetentionMs)
   ) {
     const jobId = enqueuePruneOldLlmRequestLogsJob(

package/src/plugins/defaults/memory/memory-db.ts

@@ -5,8 +5,9 @@ const log = getLogger("memory-db");
 
 /**
  * The plugin's accessor for the dedicated memory database
- * (`assistant-memory.db`), where the memory plugin's relocated tables live
- * (`memory_v2_injection_events`, with more to follow).
+ * (`assistant-memory.db`), where the memory plugin's relocated tables live.
+ * The `move-*-to-memory-db` migrations in `persistence/migrations/` define
+ * the current set of relocated tables.
  *
  * Fail-soft: returns `null` when the file cannot be opened, logging a warn
  * tagged with the calling context. Callers degrade rather than throw — the

package/src/plugins/defaults/memory/memory-recall-log-store.ts

@@ -1,8 +1,9 @@
-import { and, eq, inArray, isNull } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { getDb } from "../../../persistence/db-connection.js";
-import { memoryRecallLogs } from "../../../persistence/schema/index.js";
+import { getLogger } from "./logging.js";
+import { memorySqliteOrNull } from "./memory-db.js";
+
+const log = getLogger("memory-recall-log-store");
 
 export interface RecordMemoryRecallLogParams {
   conversationId: string;
@@ -29,51 +30,74 @@ export interface RecordMemoryRecallLogParams {
 export function recordMemoryRecallLog(
   params: RecordMemoryRecallLogParams,
 ): void {
-  const db = getDb();
-  db.insert(memoryRecallLogs)
-    .values({
-      id: uuid(),
-      conversationId: params.conversationId,
-      messageId: null,
-      enabled: params.enabled ? 1 : 0,
-      degraded: params.degraded ? 1 : 0,
-      provider: params.provider ?? null,
-      model: params.model ?? null,
-      degradationJson: params.degradationJson
-        ? JSON.stringify(params.degradationJson)
-        : null,
-      semanticHits: params.semanticHits,
-      mergedCount: params.mergedCount,
-      selectedCount: params.selectedCount,
-      tier1Count: params.tier1Count,
-      tier2Count: params.tier2Count,
-      hybridSearchLatencyMs: params.hybridSearchLatencyMs,
-      sparseVectorUsed: params.sparseVectorUsed ? 1 : 0,
-      injectedTokens: params.injectedTokens,
-      latencyMs: params.latencyMs,
-      topCandidatesJson: JSON.stringify(params.topCandidatesJson),
-      injectedText: params.injectedText ?? null,
-      reason: params.reason ?? null,
-      queryContext: params.queryContext ?? null,
-      createdAt: Date.now(),
-    })
-    .run();
+  // Best-effort — telemetry writes must never abort the agent turn, so a
+  // degraded memory connection or a failed insert only logs a warning.
+  try {
+    const raw = memorySqliteOrNull("recordMemoryRecallLog");
+    if (!raw) {
+      return;
+    }
+    raw
+      .prepare(
+        `INSERT INTO memory_recall_logs (
+           id, conversation_id, message_id, enabled, degraded, provider,
+           model, degradation_json, semantic_hits, merged_count,
+           selected_count, tier1_count, tier2_count,
+           hybrid_search_latency_ms, sparse_vector_used, injected_tokens,
+           latency_ms, top_candidates_json, injected_text, reason,
+           query_context, created_at
+         ) VALUES (?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      )
+      .run(
+        uuid(),
+        params.conversationId,
+        params.enabled ? 1 : 0,
+        params.degraded ? 1 : 0,
+        params.provider ?? null,
+        params.model ?? null,
+        params.degradationJson ? JSON.stringify(params.degradationJson) : null,
+        params.semanticHits,
+        params.mergedCount,
+        params.selectedCount,
+        params.tier1Count,
+        params.tier2Count,
+        params.hybridSearchLatencyMs,
+        params.sparseVectorUsed ? 1 : 0,
+        params.injectedTokens,
+        params.latencyMs,
+        JSON.stringify(params.topCandidatesJson),
+        params.injectedText ?? null,
+        params.reason ?? null,
+        params.queryContext ?? null,
+        Date.now(),
+      );
+  } catch (err) {
+    log.warn({ err }, "failed to record memory recall log; continuing");
+  }
 }
 
 export function backfillMemoryRecallLogMessageId(
   conversationId: string,
   messageId: string,
 ): void {
-  const db = getDb();
-  db.update(memoryRecallLogs)
-    .set({ messageId })
-    .where(
-      and(
-        eq(memoryRecallLogs.conversationId, conversationId),
-        isNull(memoryRecallLogs.messageId),
-      ),
-    )
-    .run();
+  try {
+    const raw = memorySqliteOrNull("backfillMemoryRecallLogMessageId");
+    if (!raw) {
+      return;
+    }
+    raw
+      .prepare(
+        `UPDATE memory_recall_logs
+           SET message_id = ?
+         WHERE conversation_id = ? AND message_id IS NULL`,
+      )
+      .run(messageId, conversationId);
+  } catch (err) {
+    log.warn(
+      { err },
+      "failed to backfill memory recall log messageId; continuing",
+    );
+  }
 }
 
 export interface MemoryRecallLog {
@@ -104,9 +128,13 @@ export interface MemoryRecallLog {
  * Entries already in inspector format pass through unchanged.
  */
 export function normalizeTopCandidates(raw: unknown): unknown {
-  if (!Array.isArray(raw)) return raw;
+  if (!Array.isArray(raw)) {
+    return raw;
+  }
   return raw.flatMap((entry: Record<string, unknown>) => {
-    if (!entry || typeof entry !== "object") return [];
+    if (!entry || typeof entry !== "object") {
+      return [];
+    }
 
     // Start with a shallow copy, then apply field renames
     const { key, finalScore, semantic, recency, kind: _kind, ...rest } = entry;
@@ -137,36 +165,71 @@ export function normalizeTopCandidates(raw: unknown): unknown {
   });
 }
 
+interface MemoryRecallLogRow {
+  enabled: number;
+  degraded: number;
+  provider: string | null;
+  model: string | null;
+  degradation_json: string | null;
+  semantic_hits: number;
+  merged_count: number;
+  selected_count: number;
+  tier1_count: number;
+  tier2_count: number;
+  hybrid_search_latency_ms: number;
+  sparse_vector_used: number;
+  injected_tokens: number;
+  latency_ms: number;
+  top_candidates_json: string;
+  injected_text: string | null;
+  reason: string | null;
+  query_context: string | null;
+}
+
 export function getMemoryRecallLogByMessageIds(
   messageIds: string[],
 ): MemoryRecallLog | null {
-  if (messageIds.length === 0) return null;
-  const db = getDb();
-  const rows = db
-    .select()
-    .from(memoryRecallLogs)
-    .where(inArray(memoryRecallLogs.messageId, messageIds))
-    .all();
-  if (rows.length === 0) return null;
-  const row = rows[0]!;
+  if (messageIds.length === 0) {
+    return null;
+  }
+  const raw = memorySqliteOrNull("getMemoryRecallLogByMessageIds");
+  if (!raw) {
+    return null;
+  }
+  const placeholders = messageIds.map(() => "?").join(",");
+  const row = raw
+    .query(
+      `SELECT enabled, degraded, provider, model, degradation_json,
+              semantic_hits, merged_count, selected_count, tier1_count,
+              tier2_count, hybrid_search_latency_ms, sparse_vector_used,
+              injected_tokens, latency_ms, top_candidates_json,
+              injected_text, reason, query_context
+         FROM memory_recall_logs
+        WHERE message_id IN (${placeholders})
+        LIMIT 1`,
+    )
+    .get(...messageIds) as MemoryRecallLogRow | null;
+  if (!row) {
+    return null;
+  }
   return {
     enabled: !!row.enabled,
     degraded: !!row.degraded,
     provider: row.provider,
     model: row.model,
-    degradation: row.degradationJson ? JSON.parse(row.degradationJson) : null,
-    semanticHits: row.semanticHits,
-    mergedCount: row.mergedCount,
-    selectedCount: row.selectedCount,
-    tier1Count: row.tier1Count,
-    tier2Count: row.tier2Count,
-    hybridSearchLatencyMs: row.hybridSearchLatencyMs,
-    sparseVectorUsed: !!row.sparseVectorUsed,
-    injectedTokens: row.injectedTokens,
-    latencyMs: row.latencyMs,
-    topCandidates: normalizeTopCandidates(JSON.parse(row.topCandidatesJson)),
-    injectedText: row.injectedText,
+    degradation: row.degradation_json ? JSON.parse(row.degradation_json) : null,
+    semanticHits: row.semantic_hits,
+    mergedCount: row.merged_count,
+    selectedCount: row.selected_count,
+    tier1Count: row.tier1_count,
+    tier2Count: row.tier2_count,
+    hybridSearchLatencyMs: row.hybrid_search_latency_ms,
+    sparseVectorUsed: !!row.sparse_vector_used,
+    injectedTokens: row.injected_tokens,
+    latencyMs: row.latency_ms,
+    topCandidates: normalizeTopCandidates(JSON.parse(row.top_candidates_json)),
+    injectedText: row.injected_text,
     reason: row.reason,
-    queryContext: row.queryContext,
+    queryContext: row.query_context,
   };
 }

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

@@ -70,3 +70,11 @@ export const SKILL_CARD_MESSAGE_KIND = "skill-authored-card";
  * the `"memory_retrospective"` member of `TitleOrigin`.
  */
 export const MEMORY_RETROSPECTIVE_ORIGIN = "memory_retrospective";
+
+/**
+ * Bundled skill that provides the retrospective's authoring tools
+ * (`find_similar_skills`, `scaffold_managed_skill`, and the `skill_load`
+ * target). Preactivated for the fork wake so those tools join the turn's active
+ * set from turn 1, and matched by the permission checker's origin-scoped grant.
+ */
+export const SKILL_MANAGEMENT_SKILL_ID = "skill-management";