@vellumai/assistant 0.8.0 → 0.8.1

package/src/memory/v2/__tests__/skill-store.test.ts

@@ -39,11 +39,13 @@ interface UpsertCall {
   dense: number[];
   sparse: { indices: number[]; values: number[] };
   updatedAt: number;
+  kind?: string;
 }
 
 interface PruneCall {
   prefix: string;
   activeSuffixes: readonly string[];
+  options?: { kind?: string };
 }
 
 interface TestState {
@@ -118,8 +120,9 @@ mock.module("../qdrant.js", () => ({
   pruneSlugsWithPrefixExcept: async (
     prefix: string,
     activeSuffixes: readonly string[],
+    options?: { kind?: string },
   ) => {
-    state.pruneCalls.push({ prefix, activeSuffixes });
+    state.pruneCalls.push({ prefix, activeSuffixes, options });
   },
 }));
 
@@ -131,8 +134,12 @@ mock.module("../../../skills/catalog-cache.js", () => ({
 }));
 
 // Imported AFTER all mocks are wired so the module under test sees the stubs.
-const { seedV2SkillEntries, getSkillCapability, _resetSkillStoreForTests } =
-  await import("../skill-store.js");
+const {
+  seedV2SkillEntries,
+  getSkillCapability,
+  listSkillEntries,
+  _resetSkillStoreForTests,
+} = await import("../skill-store.js");
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -467,3 +474,51 @@ describe("getSkillCapability", () => {
     expect(getSkillCapability("does-not-exist")).toBeNull();
   });
 });
+
+describe("listSkillEntries", () => {
+  test("returns [] when the cache is empty (pre-seed)", () => {
+    expect(listSkillEntries()).toEqual([]);
+  });
+
+  test("returns entries sorted by id after seeding", async () => {
+    // Insert in non-sorted order to prove the sort happens on read.
+    const skillB = makeSummary({ id: "example-skill-b" });
+    const skillA = makeSummary({ id: "example-skill-a" });
+    state.catalog = [skillB, skillA];
+    state.resolved = [
+      { summary: skillB, state: "enabled" },
+      { summary: skillA, state: "enabled" },
+    ];
+    state.embedReturn = [
+      [0.1, 0.2, 0.3],
+      [0.4, 0.5, 0.6],
+    ];
+
+    await seedV2SkillEntries();
+
+    const list = listSkillEntries();
+    expect(list).toHaveLength(2);
+    expect(list.map((e) => e.id)).toEqual([
+      "example-skill-a",
+      "example-skill-b",
+    ]);
+  });
+
+  test("mutating the returned array does not affect subsequent calls", async () => {
+    const skillA = makeSummary({ id: "example-skill-a" });
+    state.catalog = [skillA];
+    state.resolved = [{ summary: skillA, state: "enabled" }];
+    state.embedReturn = [[0.1, 0.2, 0.3]];
+
+    await seedV2SkillEntries();
+
+    const first = listSkillEntries();
+    expect(first).toHaveLength(1);
+    first.length = 0;
+    first.push({ id: "injected", content: "junk" });
+
+    const second = listSkillEntries();
+    expect(second).toHaveLength(1);
+    expect(second[0].id).toBe("example-skill-a");
+  });
+});

package/src/memory/v2/__tests__/static-context.test.ts

@@ -45,7 +45,7 @@ mock.module("../../../config/loader.js", () => ({
   setNestedValue: () => {},
 }));
 
-const { readMemoryV2StaticContent, shouldLoadMemoryV2Static } =
+const { readMemoryV2StaticContent, shouldExposePersonalMemory } =
   await import("../static-context.js");
 
 const MEMORY_FILES = [
@@ -140,21 +140,10 @@ describe("readMemoryV2StaticContent", () => {
   });
 });
 
-describe("shouldLoadMemoryV2Static", () => {
-  test("blocks all turns until the cadence gate fires", () => {
-    expect(
-      shouldLoadMemoryV2Static({
-        shouldInjectNowAndPkb: false,
-        sourceChannel: "vellum",
-        isTrustedActor: true,
-      }),
-    ).toBe(false);
-  });
-
+describe("shouldExposePersonalMemory", () => {
   test("allows guardian-trusted local conversations", () => {
     expect(
-      shouldLoadMemoryV2Static({
-        shouldInjectNowAndPkb: true,
+      shouldExposePersonalMemory({
         sourceChannel: "vellum",
         isTrustedActor: true,
       }),
@@ -163,8 +152,7 @@ describe("shouldLoadMemoryV2Static", () => {
 
   test("allows local-channel conversations even when trust class is unknown (analyze runs, dev)", () => {
     expect(
-      shouldLoadMemoryV2Static({
-        shouldInjectNowAndPkb: true,
+      shouldExposePersonalMemory({
         sourceChannel: "vellum",
         isTrustedActor: false,
       }),
@@ -173,8 +161,7 @@ describe("shouldLoadMemoryV2Static", () => {
 
   test("allows turns with no trust context (work-item task runs, internal background)", () => {
     expect(
-      shouldLoadMemoryV2Static({
-        shouldInjectNowAndPkb: true,
+      shouldExposePersonalMemory({
         sourceChannel: undefined,
         isTrustedActor: false,
       }),
@@ -192,8 +179,7 @@ describe("shouldLoadMemoryV2Static", () => {
   test("allows guardian-trusted remote channels (user's own phone/Slack)", () => {
     for (const channel of REMOTE_CHANNELS) {
       expect(
-        shouldLoadMemoryV2Static({
-          shouldInjectNowAndPkb: true,
+        shouldExposePersonalMemory({
           sourceChannel: channel,
           isTrustedActor: true,
         }),
@@ -204,8 +190,7 @@ describe("shouldLoadMemoryV2Static", () => {
   test("blocks non-guardian remote-channel actors (the leak this gate exists to prevent)", () => {
     for (const channel of REMOTE_CHANNELS) {
       expect(
-        shouldLoadMemoryV2Static({
-          shouldInjectNowAndPkb: true,
+        shouldExposePersonalMemory({
           sourceChannel: channel,
           isTrustedActor: false,
         }),

package/src/memory/v2/__tests__/sweep-job.test.ts

@@ -62,6 +62,23 @@ mock.module("../../../providers/provider-send-message.js", () => ({
     response.content.find((b): b is ToolUseContent => b.type === "tool_use"),
 }));
 
+// emitNotificationSignal spy — captures every notification the sweep emits
+// so the failure-path test can assert on `activity.failed` shape and dedupe.
+const emitCalls: Array<Record<string, unknown>> = [];
+
+mock.module("../../../notifications/emit-signal.js", () => ({
+  emitNotificationSignal: async (params: Record<string, unknown>) => {
+    emitCalls.push(params);
+    return {
+      signalId: "sig-1",
+      deduplicated: false,
+      dispatched: true,
+      reason: "ok",
+      deliveryResults: [],
+    };
+  },
+}));
+
 // Workspace setup — temp dir per test run, pinned via VELLUM_WORKSPACE_DIR
 // so `getWorkspaceDir()` resolves to the tmpdir.
 let tmpWorkspace: string;
@@ -166,6 +183,7 @@ function extractFirstUserText(msgs: { content: unknown }[]): string {
 function seedMessages(
   conversationId: string,
   rows: Array<{ role: string; content: string; offsetMs: number }>,
+  conversationType: "standard" | "background" | "scheduled" = "standard",
 ): void {
   const db = getDb();
   const now = Date.now();
@@ -175,6 +193,7 @@ function seedMessages(
       title: null,
       createdAt: now - 60_000,
       updatedAt: now,
+      conversationType,
     })
     .run();
   for (let i = 0; i < rows.length; i++) {
@@ -200,6 +219,7 @@ beforeEach(() => {
   mkdirSync(join(tmpWorkspace, "memory"), { recursive: true });
   providerCalls.length = 0;
   providerStub = null;
+  emitCalls.length = 0;
 });
 
 // ---------------------------------------------------------------------------
@@ -417,6 +437,81 @@ describe("memoryV2SweepJob — recent messages", () => {
 
     expect(written).toBe(0);
   });
+
+  test("emits an activity.failed notification when provider.sendMessage throws", async () => {
+    // Simulate a transient provider failure once we're past the early
+    // bail checks. The sweep must (a) preserve the existing silent-failure
+    // contract by returning 0, and (b) surface the failure via the
+    // centralized notifications pipeline so the user sees it instead of
+    // the failure being silently swallowed.
+    providerStub = {
+      name: "stub",
+      sendMessage: async () => {
+        throw new Error("simulated provider failure");
+      },
+    };
+
+    const written = await memoryV2SweepJob(makeJob(), CONFIG);
+
+    expect(written).toBe(0);
+    expect(emitCalls).toHaveLength(1);
+    const emitted = emitCalls[0]!;
+    expect(emitted.sourceEventName).toBe("activity.failed");
+    expect(emitted.sourceChannel).toBe("scheduler");
+    const day = new Date().toISOString().slice(0, 10);
+    expect(emitted.dedupeKey).toBe(`activity-failed:memory.v2.sweep:${day}`);
+    const contextPayload = emitted.contextPayload as Record<string, unknown>;
+    expect(contextPayload.jobName).toBe("memory.v2.sweep");
+    expect(contextPayload.errorKind).toBe("exception");
+    expect(contextPayload.errorMessage).toContain("simulated provider failure");
+  });
+});
+
+describe("memoryV2SweepJob — background/scheduled conversation filter", () => {
+  test("excludes background/scheduled conversation content from sweep input", async () => {
+    seedMessages(
+      `conv-bg-${++convCounter}`,
+      [
+        {
+          role: "assistant",
+          content:
+            "[heartbeat] internal automation chatter that should not leak",
+          offsetMs: -60_000,
+        },
+      ],
+      "background",
+    );
+    seedMessages(
+      `conv-sched-${++convCounter}`,
+      [
+        {
+          role: "assistant",
+          content:
+            "[scheduled] scheduled-job chatter that should not leak either",
+          offsetMs: -45_000,
+        },
+      ],
+      "scheduled",
+    );
+    seedMessages(`conv-user-${++convCounter}`, [
+      {
+        role: "user",
+        content: "Bob mentioned he prefers dark mode.",
+        offsetMs: -30_000,
+      },
+    ]);
+
+    providerStub = makeEntriesProvider(["Bob prefers dark mode."]);
+
+    const written = await memoryV2SweepJob(makeJob(), CONFIG);
+
+    expect(written).toBe(1);
+    expect(providerCalls).toHaveLength(1);
+    const [{ userText }] = providerCalls;
+    expect(userText).toContain("Bob mentioned he prefers dark mode.");
+    expect(userText).not.toContain("internal automation chatter");
+    expect(userText).not.toContain("scheduled-job chatter");
+  });
 });
 
 function todaysArchiveBasename(now: Date = new Date()): string {

package/src/memory/v2/activation-store.ts

@@ -82,15 +82,44 @@ export async function save(
  * The child row inherits everInjected as-is so previously-attached slugs are
  * not re-injected on the child's first turn — matching the v1 semantics where
  * a fork carries over all in-context memories.
+ *
+ * Synchronous so it can run inside the bun:sqlite transaction that wraps
+ * `forkConversation()` — keeping the state copy atomic with the message and
+ * attachment copies.
  */
-export async function fork(
+export function forkActivationState(
   database: DrizzleDb,
   parentConversationId: string,
   newConversationId: string,
-): Promise<void> {
-  const parent = await hydrate(database, parentConversationId);
-  if (!parent) return;
-  await save(database, newConversationId, parent);
+): void {
+  const row = database
+    .select()
+    .from(activationState)
+    .where(eq(activationState.conversationId, parentConversationId))
+    .get();
+  if (!row) return;
+
+  database
+    .insert(activationState)
+    .values({
+      conversationId: newConversationId,
+      messageId: row.messageId,
+      stateJson: row.stateJson,
+      everInjectedJson: row.everInjectedJson,
+      currentTurn: row.currentTurn,
+      updatedAt: row.updatedAt,
+    })
+    .onConflictDoUpdate({
+      target: activationState.conversationId,
+      set: {
+        messageId: row.messageId,
+        stateJson: row.stateJson,
+        everInjectedJson: row.everInjectedJson,
+        currentTurn: row.currentTurn,
+        updatedAt: row.updatedAt,
+      },
+    })
+    .run();
 }
 
 /**

package/src/memory/v2/activation.ts

@@ -36,15 +36,13 @@
 
 import type { AssistantConfig } from "../../config/types.js";
 import { applyCorrectionIfCalibrated } from "../anisotropy.js";
-import {
-  embedWithBackend,
-  generateSparseEmbedding,
-} from "../embedding-backend.js";
+import { embedWithBackend } from "../embedding-backend.js";
 import { clampUnitInterval } from "../validation.js";
 import type { EdgeIndex } from "./edge-index.js";
 import { hybridQueryConceptPages } from "./qdrant.js";
 import { rerankCandidates } from "./reranker.js";
 import { simBatch } from "./sim.js";
+import { generateBm25QueryEmbedding } from "./sparse-bm25.js";
 import type { ActivationState, EverInjectedEntry } from "./types.js";
 
 /**
@@ -125,12 +123,13 @@ export async function selectCandidates(
 
   // (2) ANN top-50 against the concatenated turn text. Pure whitespace joins
   // (no separators) keep the embedding behavior aligned with how callers
-  // would naturally read the three texts together.
+  // would naturally read the three texts together. Whitespace-only channels
+  // contribute no semantic content, so trim before deciding whether to embed.
   const annQueryText = [userText, assistantText, nowText]
-    .filter((s) => s.length > 0)
+    .filter((s) => s.trim().length > 0)
     .join("\n");
 
-  if (annQueryText.length > 0) {
+  if (annQueryText.trim().length > 0) {
     throwIfAborted(signal);
     const denseResult = await embedWithBackend(config, [annQueryText], {
       signal,
@@ -141,7 +140,7 @@ export async function selectCandidates(
       denseResult.model,
     );
     throwIfAborted(signal);
-    const sparse = generateSparseEmbedding(annQueryText);
+    const sparse = generateBm25QueryEmbedding(annQueryText);
     const limit =
       config.memory.v2.ann_candidate_limit ?? UNLIMITED_ANN_CANDIDATE_LIMIT;
     const hits = await hybridQueryConceptPages(dense, sparse, limit);
@@ -202,17 +201,19 @@ interface ComputeOwnActivationResult {
  *          + c_user · sim_u + c_assistant · sim_a + c_now · sim_n
  *          + c_user · α · r_norm_u + c_assistant · α · r_norm_a
  * over the candidate set, where the rerank terms only fire for slugs that
- * land in the unified top-K-by-pre-rerank-A_o window. Returns a sparse map
- * keyed by slug; slugs whose computed value rounds to 0 are still included
- * so callers can see the candidate set explicitly. Also returns a per-slug
- * breakdown of the raw inputs (decayed prior + raw sims + rerank deltas) so
- * callers can render contribution diagnostics without re-running the math.
+ * land in the unified top-K window. The pool is ranked by the rerank-eligible
+ * channels alone (`c_user · sim_u + c_assistant · sim_a`) so prior- or
+ * NOW-heavy slugs — which can't gain from rerank — don't starve out
+ * genuinely user/assistant-relevant slugs. Returns a sparse map keyed by
+ * slug; slugs whose computed value rounds to 0 are still included so callers
+ * can see the candidate set explicitly. Also returns a per-slug breakdown of
+ * the raw inputs (decayed prior + raw sims + rerank deltas) so callers can
+ * render contribution diagnostics without re-running the math.
  *
  * The three `simBatch` calls run concurrently — they hit independent named
  * vectors and embed independent query texts. Cross-encoder rerank then runs
- * once on the unified top-K (selected by pre-rerank A_o, not per-channel
- * fused sim) so an entry strong in both channels can't double-boost itself
- * past entries that only land in one channel.
+ * once on the unified top-K so an entry strong in both channels can't
+ * double-boost itself past entries that only land in one channel.
  */
 export async function computeOwnActivation(
   params: ComputeOwnActivationParams,
@@ -248,8 +249,16 @@ export async function computeOwnActivation(
     simU: number;
     simA: number;
     simN: number;
-    /** Pre-rerank A_o; ranking signal for the unified rerank pool. */
+    /** Pre-rerank A_o; full sum used for the final activation value. */
     preRerank: number;
+    /**
+     * Ranking signal for the unified rerank pool — only the channels that
+     * actually participate in rerank (user + assistant). Excluding
+     * `priorContribution` and `c_now * simN` prevents prior- or NOW-heavy
+     * slugs from consuming the rerank budget despite being ineligible for
+     * cross-encoder gains.
+     */
+    rerankPoolScore: number;
   }
   const inputs: SlugInputs[] = slugList.map((slug) => {
     const prev = priorState?.state[slug] ?? 0;
@@ -257,23 +266,24 @@ export async function computeOwnActivation(
     const simA = simAssistant.get(slug) ?? 0;
     const simN = simNow.get(slug) ?? 0;
     const priorContribution = d * prev;
+    const rerankPoolScore = c_user * simU + c_assistant * simA;
     return {
       slug,
       priorContribution,
       simU,
       simA,
       simN,
-      preRerank:
-        priorContribution + c_user * simU + c_assistant * simA + c_now * simN,
+      preRerank: priorContribution + rerankPoolScore + c_now * simN,
+      rerankPoolScore,
     };
   });
 
-  // Unified top-K by pre-rerank A_o. Both channels rerank against the **same**
-  // slug set, so a slug strong on user can't crowd out one strong on assistant
-  // by virtue of appearing in both per-channel top-Ks. Both channel queries
-  // ride in a single `rerankCandidates` call so the worker tokenizes and
-  // forward-passes them together — half the per-call overhead of two
-  // serialised round-trips.
+  // Unified top-K by rerank-eligible signal only. Both channels rerank against
+  // the **same** slug set, so a slug strong on user can't crowd out one strong
+  // on assistant by virtue of appearing in both per-channel top-Ks. Both
+  // channel queries ride in a single `rerankCandidates` call so the worker
+  // tokenizes and forward-passes them together — half the per-call overhead
+  // of two serialised round-trips.
   let userRerankBoost: ReadonlyMap<string, number> = new Map();
   let assistantRerankBoost: ReadonlyMap<string, number> = new Map();
   let inPoolSet: ReadonlySet<string> = new Set();
@@ -282,17 +292,20 @@ export async function computeOwnActivation(
     throwIfAborted(signal);
     const topSlugs = inputs
       .slice()
-      .sort((a, b) => b.preRerank - a.preRerank)
+      .sort((a, b) => b.rerankPoolScore - a.rerankPoolScore)
       .slice(0, rerankCfg.top_k)
       .map((e) => e.slug);
     if (topSlugs.length > 0) {
-      inPoolSet = new Set(topSlugs);
       const [userScores, assistantScores] = await rerankCandidates(
         [userText, assistantText],
         topSlugs,
         config,
       );
       throwIfAborted(signal);
+      // Build the pool from slugs the cross-encoder actually scored, so a
+      // backend failure (which yields empty maps) doesn't mislabel candidates
+      // as `inRerankPool` in the inspector.
+      inPoolSet = new Set([...userScores.keys(), ...assistantScores.keys()]);
       userRerankBoost = normalizeRerankScores(userScores, rerankCfg.alpha);
       assistantRerankBoost = normalizeRerankScores(
         assistantScores,

package/src/memory/v2/backfill-jobs.ts

@@ -7,8 +7,7 @@
 //
 //   - `memory_v2_migrate`              — one-shot v1→v2 synthesis (PR 16).
 //   - `memory_v2_reembed`              — fan out an `embed_concept_page` job
-//     per slug, plus four reserved-slug jobs for the meta files
-//     (`__essentials__`, `__threads__`, `__recent__`, `__buffer__`).
+//     per concept-page slug.
 //   - `memory_v2_activation_recompute` — recompute persisted activation
 //     state for every conversation, no rendering. Used after consolidation
 //     replaces or deletes pages that other conversations still reference.
@@ -19,9 +18,6 @@
 // the same code paths exercised by tests of those modules run unchanged when
 // a backfill kicks them off.
 
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-
 import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
@@ -30,6 +26,7 @@ import { listConversations } from "../conversation-queries.js";
 import { getDb } from "../db-connection.js";
 import { enqueueEmbedConceptPageJob } from "../jobs/embed-concept-page.js";
 import type { MemoryJob } from "../jobs-store.js";
+import { stringifyMessageContent } from "../message-content.js";
 import {
   computeOwnActivation,
   selectCandidates,
@@ -41,25 +38,11 @@ import {
   MigrationAlreadyAppliedError,
   runMemoryV2Migration,
 } from "./migration.js";
+import { loadNowText } from "./now-text.js";
 import { listPages } from "./page-store.js";
 
 const log = getLogger("memory-v2-backfill");
 
-/**
- * Reserved slugs the reembed job enqueues alongside the concept-page slugs.
- * These name the four prose meta files (essentials/threads/recent/buffer)
- * loaded into the system prompt by PR 11. Embedding them is forward-looking
- * — the existing `embed-concept-page` handler treats unknown slugs as
- * deletions (a no-op when no embedding exists), so enqueueing here is safe
- * regardless of whether the meta files are ever embedded for retrieval.
- */
-export const META_FILE_SLUGS = [
-  "__essentials__",
-  "__threads__",
-  "__recent__",
-  "__buffer__",
-] as const;
-
 // ---------------------------------------------------------------------------
 // memory_v2_migrate — wraps runMemoryV2Migration
 // ---------------------------------------------------------------------------
@@ -106,16 +89,22 @@ export async function memoryV2MigrateJob(
 }
 
 // ---------------------------------------------------------------------------
-// memory_v2_reembed — fan out embed jobs for every page + meta file
+// memory_v2_reembed — fan out embed jobs for every concept page
 // ---------------------------------------------------------------------------
 
 /**
- * Job handler: enqueue an `embed_concept_page` job per concept-page slug, plus
- * one job per reserved meta-file slug ({@link META_FILE_SLUGS}).
+ * Job handler: enqueue an `embed_concept_page` job per concept-page slug.
+ *
+ * Returns the total number of jobs enqueued. Callers (and tests) use the
+ * return value to assert progress without inspecting the job table directly.
  *
- * Returns the total number of jobs enqueued — `concept-page count + 4`.
- * Callers (and tests) use the return value to assert progress without
- * inspecting the job table directly.
+ * Note on meta files: `essentials.md` / `threads.md` / `recent.md` /
+ * `buffer.md` are direct-injected into the system prompt every turn via
+ * `_autoinject.md`. They are NOT enqueued for embedding here — their slugs
+ * (`__essentials__` etc.) contain underscores that the concept-page slug
+ * validator rejects (`[a-z0-9][a-z0-9-]*`), and they live at `memory/<name>.md`
+ * rather than `memory/concepts/<name>.md`, so path resolution would also miss.
+ * Embedding them would be redundant with the direct injection regardless.
  */
 export async function memoryV2ReembedJob(
   _job: MemoryJob,
@@ -127,16 +116,12 @@ export async function memoryV2ReembedJob(
   for (const slug of slugs) {
     enqueueEmbedConceptPageJob({ slug });
   }
-  for (const slug of META_FILE_SLUGS) {
-    enqueueEmbedConceptPageJob({ slug });
-  }
 
-  const total = slugs.length + META_FILE_SLUGS.length;
   log.info(
-    { conceptPages: slugs.length, metaFiles: META_FILE_SLUGS.length, total },
+    { conceptPages: slugs.length, total: slugs.length },
     "Memory v2 reembed enqueued",
   );
-  return total;
+  return slugs.length;
 }
 
 // ---------------------------------------------------------------------------
@@ -303,55 +288,3 @@ function lastExchangeTexts(conversationId: string): {
   }
   return { userText, assistantText };
 }
-
-/**
- * Coerce stored message content (JSON-serialized `ContentBlock[]` *or* plain
- * string in legacy rows) into a single text string. Image / tool blocks are
- * dropped — recompute only needs the spoken text.
- */
-function stringifyMessageContent(stored: string): string {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(stored);
-  } catch {
-    return stored.trim();
-  }
-  if (typeof parsed === "string") return parsed.trim();
-  if (!Array.isArray(parsed)) return "";
-  const parts: string[] = [];
-  for (const block of parsed) {
-    if (
-      block &&
-      typeof block === "object" &&
-      (block as { type?: string }).type === "text" &&
-      typeof (block as { text?: unknown }).text === "string"
-    ) {
-      parts.push((block as { text: string }).text);
-    }
-  }
-  return parts.join("\n").trim();
-}
-
-/**
- * Read the prose meta files that compose the "NOW" context the activation
- * pipeline correlates against. Mirrors the autoload order in
- * `system-prompt.ts` so the same prose drives both injection and recompute.
- * Missing or unreadable files are treated as empty.
- */
-async function loadNowText(workspaceDir: string): Promise<string> {
-  const filenames = ["essentials.md", "threads.md", "recent.md"];
-  const reads = await Promise.all(
-    filenames.map(async (filename) => {
-      try {
-        const text = await readFile(
-          join(workspaceDir, "memory", filename),
-          "utf-8",
-        );
-        return text.trim();
-      } catch {
-        return "";
-      }
-    }),
-  );
-  return reads.filter((part) => part.length > 0).join("\n\n");
-}