@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/router.ts

@@ -15,12 +15,17 @@
  * cache turn after turn. The trailing recent-context / current-message block
  * changes every turn, so it carries no breakpoint.
  *
- * Recall-safe fallbacks. The router exists to widen recall, so every failure
- * mode degrades toward opening MORE leaves, never fewer:
- *   - omitted `ids` (model didn't pass the field) → open ALL leaves,
- *   - missing/failed tool_use, provider unavailable, or any throw → ALL leaves.
- * The one path that returns nothing is an explicit empty array (`ids: []`),
- * which is the model deliberately abstaining.
+ * Failure handling. A *model-call* failure is not the same as the model
+ * choosing to open everything, so the two no longer share an outcome:
+ *   - explicit `ids` → open exactly those leaves,
+ *   - explicit empty array (`ids: []`) → open nothing (deliberate abstention),
+ *   - omitted `ids` → open nothing: the router must name the leaves it wants,
+ *     never the whole tree (~137 leaves would fan out a full L2 pass per turn),
+ *   - infrastructure failure (provider unavailable, a throw that survived the
+ *     provider's own retries, no usable `tool_use`, or a schema mismatch) →
+ *     open nothing after a short re-prompt retry, degrading to the deterministic
+ *     recall lanes (always-on core, the BM25 needle, the carry-forward working
+ *     set) that the orchestrator unions in regardless.
  */
 
 import { z } from "zod";
@@ -28,9 +33,10 @@ import { z } from "zod";
 import {
   extractToolUse,
   getConfiguredProvider,
-} from "../../providers/provider-send-message.js";
-import type { Message, ToolDefinition } from "../../providers/types.js";
-import { getLogger } from "../../util/logger.js";
+} from "../../../providers/provider-send-message.js";
+import type { Message, ToolDefinition } from "../../../providers/types.js";
+import { getLogger } from "../../../util/logger.js";
+import { retryForResult } from "./llm-retry.js";
 import { cachedTextBlock } from "./provider-blocks.js";
 import type { LeafPath, LeafTree, TurnContext } from "./types.js";
 
@@ -40,8 +46,8 @@ const log = getLogger("memory-v3-router");
 const OPEN_LEAVES_TOOL_NAME = "open_leaves";
 
 const OpenLeavesSchema = z.object({
-  // Optional: an omitted `ids` field is the recall-safe "open everything"
-  // signal, distinct from an explicit empty array (deliberate abstention).
+  // Optional so the field can be absent on the wire, but an omitted `ids` opens
+  // nothing — the router must name the leaves it wants, never the whole tree.
   ids: z.array(z.number().int()).optional(),
 });
 
@@ -50,8 +56,8 @@ const OPEN_LEAVES_TOOL: ToolDefinition = {
   description:
     "Open the leaves whose contents could plausibly bear on the next reply. " +
     "Lean toward inclusion — a missed relevant leaf is a worse error than an " +
-    "unused one. Omit `ids` entirely to open every leaf; return `[]` only " +
-    "when nothing in the tree could possibly help.",
+    "unused one. Pass the chosen IDs explicitly; return `[]` only when nothing " +
+    "in the tree could possibly help.",
   input_schema: {
     type: "object",
     properties: {
@@ -65,13 +71,14 @@ const OPEN_LEAVES_TOOL: ToolDefinition = {
 
 const SYSTEM_PROMPT = `You route a conversation turn to the leaves of a topic tree that should be opened for the next reply.
 
-Each leaf has a numbered ID, a path, and a description of what it holds. Decide which leaves to open by weighing three signals:
+Each leaf has a numbered ID, a path, and a description of what it holds. Decide which leaves to open by weighing four signals:
 
 - Topic — entities, projects, and events named or implied by the turn.
 - Register — the affect and mode of the message (e.g. playful, distressed, formal). A register signal is enough to open a leaf even when no entity is named.
 - Recent context — the immediately preceding exchange, which resolves references like "this", "that", or "the same thing" to concrete topics.
+- Situation — the current date and a live scratchpad of what is salient right now. A date or state cue can make a leaf relevant even when the message never names it (e.g. a person whose anniversary is today, an active thread).
 
-Include on doubt: open every leaf that could plausibly hold something useful. Missing a relevant leaf is a worse error than opening an unused one. Call \`open_leaves\` with the chosen IDs. Omit \`ids\` to open every leaf; return \`[]\` only when nothing in the tree could possibly help.`;
+Include on doubt: open every leaf that could plausibly hold something useful. Missing a relevant leaf is a worse error than opening an unused one. Call \`open_leaves\` with the chosen IDs explicitly; return \`[]\` only when nothing in the tree could possibly help.`;
 
 /** Leaves sorted deterministically by path so the numbered block is stable. */
 function sortedLeaves(tree: LeafTree): LeafPath[] {
@@ -104,10 +111,10 @@ export function renderLeafBlock(tree: LeafTree): string {
 }
 
 /**
- * Run the L1 router for one turn. Returns the leaf paths to open.
- *
- * Recall-safe: any failure to obtain an explicit selection returns ALL leaves.
- * Only an explicit empty `ids` array returns no leaves.
+ * Run the L1 router for one turn. Returns the leaf paths to open — only ever the
+ * leaves the model names explicitly. An omitted `ids`, an explicit `[]`, or an
+ * infrastructure failure (after a short re-prompt retry) all open nothing,
+ * degrading to the deterministic recall lanes the orchestrator unions in.
  */
 export async function routeL1(
   turn: TurnContext,
@@ -118,8 +125,10 @@ export async function routeL1(
 
   const provider = await getConfiguredProvider("memoryV3RouteL1");
   if (!provider) {
-    log.warn("memoryV3RouteL1 provider unavailable; opening all leaves");
-    return paths;
+    log.warn(
+      "L1 router provider unavailable; degrading to deterministic lanes",
+    );
+    return [];
   }
 
   const userMsg: Message = {
@@ -129,15 +138,21 @@ export async function routeL1(
       {
         type: "text",
         text:
+          (turn.situationalContext
+            ? `<situation>${turn.situationalContext}</situation>\n`
+            : "") +
           `<recent_context>${turn.recentContext}</recent_context>\n` +
           `<current_message>${turn.currentMessage}</current_message>`,
       },
     ],
   };
 
-  let response;
-  try {
-    response = await provider.sendMessage([userMsg], {
+  // One forced-tool call, retried a few times so a transient malformed response
+  // (no usable tool_use, or tool input that fails the schema) re-prompts before
+  // we give up. `null` from an attempt means "unusable, retry"; the provider
+  // layer already backs off transient throws, so this loop adds no delay.
+  const parsed = await retryForResult(async () => {
+    const response = await provider.sendMessage([userMsg], {
       tools: [OPEN_LEAVES_TOOL],
       systemPrompt: SYSTEM_PROMPT,
       config: {
@@ -145,37 +160,28 @@ export async function routeL1(
         tool_choice: { type: "tool" as const, name: OPEN_LEAVES_TOOL_NAME },
       },
     });
-  } catch (err) {
-    log.warn({ err }, "L1 router call threw; opening all leaves");
-    return paths;
-  }
-
-  const toolBlock = extractToolUse(response);
-  if (!toolBlock || toolBlock.name !== OPEN_LEAVES_TOOL_NAME) {
-    log.warn(
-      { stopReason: response.stopReason },
-      "L1 router returned no open_leaves tool_use; opening all leaves",
-    );
-    return paths;
-  }
+    const toolBlock = extractToolUse(response);
+    if (!toolBlock || toolBlock.name !== OPEN_LEAVES_TOOL_NAME) return null;
+    const result = OpenLeavesSchema.safeParse(toolBlock.input);
+    return result.success ? result.data : null;
+  });
 
-  const parsed = OpenLeavesSchema.safeParse(toolBlock.input);
-  if (!parsed.success) {
+  if (parsed === null) {
     log.warn(
-      { error: parsed.error.message },
-      "L1 router tool input did not match schema; opening all leaves",
+      "L1 router could not obtain a selection after retries; degrading to deterministic lanes",
     );
-    return paths;
+    return [];
   }
 
-  // Omitted `ids` is the recall-safe "open everything" signal.
-  if (parsed.data.ids === undefined) return paths;
+  // An omitted `ids` field means the model named no leaves — open nothing rather
+  // than the whole tree. Only explicitly listed IDs open leaves.
+  if (parsed.ids === undefined) return [];
 
   // Map 1-based IDs back to leaf paths, dropping out-of-range IDs without
   // throwing. De-duplicate while preserving model-returned order.
   const seen = new Set<number>();
   const selected: LeafPath[] = [];
-  for (const id of parsed.data.ids) {
+  for (const id of parsed.ids) {
     if (id < 1 || id > paths.length || seen.has(id)) continue;
     seen.add(id);
     selected.push(paths[id - 1]);

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/selection-log-store.ts

@@ -7,10 +7,10 @@
  * across turns) and can't be reproduced after the fact.
  */
 
-import type { MemoryV3SelectionLog } from "../../api/responses/memory-v3-selection-log.js";
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
-import { getConfig } from "../../config/loader.js";
-import { getDb, getSqliteFrom } from "../db-connection.js";
+import type { MemoryV3SelectionLog } from "../../../api/responses/memory-v3-selection-log.js";
+import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
+import { getConfig } from "../../../config/loader.js";
+import { getDb, getSqliteFrom } from "../../../memory/db-connection.js";
 import { renderV3PageContent } from "./page-content.js";
 import { renderMemoryBlock } from "./render-injection.js";
 import type { Slug } from "./types.js";

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/selector.ts

@@ -14,11 +14,18 @@
  * turn after turn. The trailing recent-context / current-message block changes
  * every turn and carries no breakpoint. This mirrors `./router.ts`.
  *
- * Recall-safe fallbacks. Like the router, the selector exists to widen recall,
- * so every failure degrades toward selecting MORE pages, never fewer:
- *   - omitted `ids` → select ALL members of the leaf,
- *   - missing/failed tool_use, provider unavailable, or any throw → ALL members.
- * Only an explicit empty `ids: []` returns nothing (deliberate abstention).
+ * Failure handling. A deliberate "select everything" and a model-call failure
+ * are different events with different outcomes:
+ *   - explicit `ids` → select exactly those pages,
+ *   - explicit empty `ids: []` → select nothing (deliberate abstention),
+ *   - omitted `ids` → select ALL members of the leaf (the recall-safe "this
+ *     whole leaf is relevant" signal, e.g. "give me all of X"); bounded to one
+ *     leaf, so unlike the router this stays a select-all,
+ *   - infrastructure failure (provider unavailable, a throw that survived the
+ *     provider's own retries, no usable `tool_use`, or a schema mismatch) →
+ *     select nothing after a short re-prompt retry, degrading to the
+ *     deterministic recall lanes (core, needle, carry-forward working set) the
+ *     orchestrator unions in regardless.
  */
 
 import { z } from "zod";
@@ -26,10 +33,11 @@ import { z } from "zod";
 import {
   extractToolUse,
   getConfiguredProvider,
-} from "../../providers/provider-send-message.js";
-import type { Message, ToolDefinition } from "../../providers/types.js";
-import { getLogger } from "../../util/logger.js";
-import { mapLimit } from "../../util/map-limit.js";
+} from "../../../providers/provider-send-message.js";
+import type { Message, ToolDefinition } from "../../../providers/types.js";
+import { getLogger } from "../../../util/logger.js";
+import { mapLimit } from "../../../util/map-limit.js";
+import { retryForResult } from "./llm-retry.js";
 import { cachedTextBlock } from "./provider-blocks.js";
 import { membersOf } from "./tree.js";
 import type { LeafPath, LeafTree, Slug, TurnContext } from "./types.js";
@@ -55,11 +63,13 @@ const SelectPagesSchema = z.object({
 const SELECT_PAGES_TOOL: ToolDefinition = {
   name: SELECT_PAGES_TOOL_NAME,
   description:
-    "Select the pages in this leaf whose content is relevant or useful for " +
-    "the next reply. Lean toward inclusion — a missed relevant page is a " +
-    "worse error than an unused one. Pass `pinned_ids` for pages the " +
-    "conversation is centrally about. Omit `ids` entirely to select every " +
-    "page; return `[]` only when none of the pages could possibly help.",
+    "Select the pages in this leaf whose content the reply would directly " +
+    "draw on. Be selective — prefer a few precisely-relevant pages over many " +
+    "loosely-related ones; a leaf opened on a weak signal may yield none. " +
+    "Pass `pinned_ids` for pages the conversation is centrally about. Omit " +
+    "`ids` only as a recall-safe fallback when you cannot judge the leaf " +
+    "(selects every page); return `[]` when pages are present but none are " +
+    "directly relevant.",
   input_schema: {
     type: "object",
     properties: {
@@ -75,11 +85,13 @@ const SELECT_PAGES_TOOL: ToolDefinition = {
   },
 };
 
-const SYSTEM_PROMPT = `This leaf of the topic tree is potentially relevant to the conversation. Select the pages whose content is relevant or useful for responding.
+const SYSTEM_PROMPT = `This leaf of the topic tree is potentially relevant to the conversation. Select ONLY the pages whose content the reply to THIS message would directly draw on.
 
-Be inclusive — include frame and affect matches, not just literal-topic matches. A page that shares the conversation's mode or register can be as useful as one that names the same entity. Missing a relevant page is a worse error than selecting an unused one.
+Be selective: exclude pages that are merely topically adjacent, part of the ever-present background, or only loosely related. Most opened leaves should contribute a few precisely-relevant pages, not most of their contents — a leaf opened on a weak signal may yield none.
 
-If the conversation is centrally ABOUT a page (rather than only peripherally relevant to it), mark that page as pinned. Call \`select_pages\` with the chosen IDs. Omit \`ids\` to select every page; return \`[]\` only when none of the pages could possibly help.`;
+A page can also be directly relevant because of the current situation — the date or the live scratchpad — not only the message: keep a page the situation makes pertinent (e.g. a person whose anniversary is today).
+
+If the conversation is centrally ABOUT a page (rather than only peripherally relevant to it), mark that page as pinned. Call \`select_pages\` with the chosen IDs. Omit \`ids\` only as a recall-safe fallback when you cannot judge the leaf (selects every page); return \`[]\` when the pages are present but none are directly relevant.`;
 
 /**
  * Render the STATIC numbered `<pages>` block for a leaf from its member slugs.
@@ -103,8 +115,10 @@ async function renderPagesBlock(
 /**
  * Run the L2 selector for a single opened leaf. Returns the pages to inject.
  *
- * Recall-safe: any failure to obtain an explicit selection returns ALL members
- * of the leaf. Only an explicit empty `ids` array returns no pages.
+ * An omitted `ids` selects ALL members (the recall-safe "whole leaf is
+ * relevant" signal); an explicit `[]` selects none; an infrastructure failure
+ * (after a short re-prompt retry) selects none, degrading to the deterministic
+ * recall lanes the orchestrator unions in.
  */
 export async function selectFromLeaf(
   leaf: LeafPath,
@@ -120,8 +134,11 @@ export async function selectFromLeaf(
 
   const provider = await getConfiguredProvider("memoryV3SelectL2");
   if (!provider) {
-    log.warn({ leaf }, "memoryV3SelectL2 provider unavailable; selecting all");
-    return allMembers();
+    log.warn(
+      { leaf },
+      "L2 selector provider unavailable; degrading to deterministic lanes",
+    );
+    return [];
   }
 
   const userMsg: Message = {
@@ -134,15 +151,21 @@ export async function selectFromLeaf(
       {
         type: "text",
         text:
+          (turn.situationalContext
+            ? `<situation>${turn.situationalContext}</situation>\n`
+            : "") +
           `<recent_context>${turn.recentContext}</recent_context>\n` +
           `<current_message>${turn.currentMessage}</current_message>`,
       },
     ],
   };
 
-  let response;
-  try {
-    response = await provider.sendMessage([userMsg], {
+  // One forced-tool call, retried a few times so a transient malformed response
+  // (no usable tool_use, or tool input that fails the schema) re-prompts before
+  // we give up. `null` from an attempt means "unusable, retry"; the provider
+  // layer already backs off transient throws, so this loop adds no delay.
+  const parsed = await retryForResult(async () => {
+    const response = await provider.sendMessage([userMsg], {
       tools: [SELECT_PAGES_TOOL],
       systemPrompt: SYSTEM_PROMPT,
       config: {
@@ -150,39 +173,31 @@ export async function selectFromLeaf(
         tool_choice: { type: "tool" as const, name: SELECT_PAGES_TOOL_NAME },
       },
     });
-  } catch (err) {
-    log.warn({ err, leaf }, "L2 selector call threw; selecting all");
-    return allMembers();
-  }
-
-  const toolBlock = extractToolUse(response);
-  if (!toolBlock || toolBlock.name !== SELECT_PAGES_TOOL_NAME) {
-    log.warn(
-      { stopReason: response.stopReason, leaf },
-      "L2 selector returned no select_pages tool_use; selecting all",
-    );
-    return allMembers();
-  }
+    const toolBlock = extractToolUse(response);
+    if (!toolBlock || toolBlock.name !== SELECT_PAGES_TOOL_NAME) return null;
+    const result = SelectPagesSchema.safeParse(toolBlock.input);
+    return result.success ? result.data : null;
+  });
 
-  const parsed = SelectPagesSchema.safeParse(toolBlock.input);
-  if (!parsed.success) {
+  if (parsed === null) {
     log.warn(
-      { error: parsed.error.message, leaf },
-      "L2 selector tool input did not match schema; selecting all",
+      { leaf },
+      "L2 selector could not obtain a selection after retries; degrading to deterministic lanes",
     );
-    return allMembers();
+    return [];
   }
 
-  // Omitted `ids` is the recall-safe "select everything" signal.
-  if (parsed.data.ids === undefined) return allMembers();
+  // Omitted `ids` is the recall-safe "this whole leaf is relevant" signal.
+  // Bounded to one leaf, so it stays a select-all (unlike the L1 router).
+  if (parsed.ids === undefined) return allMembers();
 
-  const pinned = new Set(parsed.data.pinned_ids ?? []);
+  const pinned = new Set(parsed.pinned_ids ?? []);
 
   // Map 1-based IDs back to member slugs, dropping out-of-range IDs without
   // throwing. De-duplicate while preserving model-returned order.
   const seen = new Set<number>();
   const selected: SelectedPage[] = [];
-  for (const id of parsed.data.ids) {
+  for (const id of parsed.ids) {
     if (id < 1 || id > members.length || seen.has(id)) continue;
     seen.add(id);
     selected.push({ slug: members[id - 1]!, pinned: pinned.has(id) });

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/shadow-plugin.ts

@@ -1,18 +1,18 @@
 /**
- * Memory v3 — flag-gated shadow/live plugin.
+ * Memory v3 — flag-gated shadow/live orchestration engine.
  *
- * Registered as an {@link Injector} that runs the v3 orchestrator each turn and
- * records its selection set to `memory_v3_selections`. Two flags gate its
- * injection behavior:
+ * Runs the v3 orchestrator each turn and records its selection set to
+ * `memory_v3_selections`. Two flags gate behavior:
  *
- *   - `memory-v3-shadow` (and live OFF): observation-only. `produce()` returns
- *     `null`, so v2 injection is bit-for-bit identical whether the flag is on
- *     or off — the only difference is the side-effect telemetry write.
- *   - `memory-v3-live`: live injection. `produce()` additionally renders the
- *     working-set selection into a `<memory>` block via {@link renderMemoryBlock}
- *     and returns it as an injection block at v2's dynamic-memory placement
+ *   - `memory-v3-shadow` (live OFF): observation-only. {@link observeTurn}
+ *     orchestrates and logs the selection set; no injection is produced, so v2
+ *     injection is bit-for-bit identical — the only difference is the
+ *     side-effect telemetry write.
+ *   - `memory-v3-live`: live injection. The injector (`memoryV3Injector` in
+ *     `./injector.ts`) additionally renders the working-set selection into a
+ *     `<memory>` block and returns it at v2's dynamic-memory placement
  *     (`after-memory-prefix`). Selections are still logged.
- *   - both OFF: `produce()` returns `null` and skips orchestration entirely.
+ *   - both OFF: orchestration is skipped entirely.
  *
  * On each turn (either flag on):
  *   1. Lazy-init the v3 lanes ONCE across the whole process (leaf tree, core
@@ -22,49 +22,45 @@
  *   3. Run {@link orchestrate} and record its selection set to
  *      `memory_v3_selections` with a best-effort lane attribution.
  *
- * Everything after the flag read is wrapped in try/catch — any failure is
- * logged and swallowed so it can never affect the live turn. In live mode a
- * failure returns `null` (no v3 injection); v2 suppression keys off BOTH the
- * flag AND whether `produce()` actually returned a block, so a v3 failure (or
- * empty selection) falls back to v2 memory rather than dropping all memory.
+ * {@link observeTurn} wraps everything after the flag read in try/catch — any
+ * failure is logged and swallowed so it can never affect the live turn. The
+ * injector treats a `null`/empty result as "no v3 injection", so v2 memory
+ * remains the fallback rather than dropping all memory.
  */
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
-import { getConfig } from "../../config/loader.js";
-import type { AssistantConfig } from "../../config/schema.js";
-import { getMessages } from "../../memory/conversation-crud.js";
-import { getDb, getSqliteFrom } from "../../memory/db-connection.js";
-import { stringifyMessageContent } from "../../memory/message-content.js";
+import { existsSync, readFileSync } from "node:fs";
+
+import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
+import { getConfig } from "../../../config/loader.js";
+import type { AssistantConfig } from "../../../config/schema.js";
+import { getMessages } from "../../../memory/conversation-crud.js";
+import { getDb, getSqliteFrom } from "../../../memory/db-connection.js";
+import { stringifyMessageContent } from "../../../memory/message-content.js";
+import { getPageIndex } from "../../../memory/v2/page-index.js";
+import { getLogger } from "../../../util/logger.js";
 import {
-  type InjectionBlock,
-  type Injector,
-  type Plugin,
-  type TurnContext as PluginTurnContext,
-} from "../../plugins/types.js";
-import { getLogger } from "../../util/logger.js";
-import { getWorkspaceDir } from "../../util/platform.js";
-import { getPageIndex } from "../v2/page-index.js";
+  getWorkspaceDir,
+  getWorkspacePromptPath,
+} from "../../../util/platform.js";
+import { stripCommentLines } from "../../../util/strip-comment-lines.js";
 import { injectCapabilitiesLeaf, isCapabilitySlug } from "./capabilities.js";
 import { loadCore } from "./core.js";
 import type { NeedleIndex } from "./needle.js";
 import { buildNeedleIndex } from "./needle.js";
 import type { OrchestrateResult } from "./orchestrate.js";
 import { orchestrate } from "./orchestrate.js";
-import { renderV3PageContent } from "./page-content.js";
-import { renderMemoryBlock } from "./render-injection.js";
 import { coreSlugs, loadLeafTree, resolveDataDir } from "./tree.js";
 import {
   type LeafPath,
   type LeafTree,
-  MEMORY_V3_BLOCK_ID,
   type SelectionSource,
   type Slug,
   type TurnContext,
 } from "./types.js";
 import { WorkingSet } from "./working-set.js";
 
-const MEMORY_V3_SHADOW = "memory-v3-shadow" as const;
-const MEMORY_V3_LIVE = "memory-v3-live" as const;
+export const MEMORY_V3_SHADOW = "memory-v3-shadow" as const;
+export const MEMORY_V3_LIVE = "memory-v3-live" as const;
 
 const log = getLogger("memory-v3-shadow");
 
@@ -165,10 +161,42 @@ function getLanes(config: AssistantConfig): Promise<ShadowLanes> {
   return lanesPromise;
 }
 
+/**
+ * Read the live NOW.md scratchpad (the user's short "what's salient right now"
+ * file), stripped of its comment lines. Mirrors `readNowScratchpad` but reads
+ * through the light platform / strip utilities directly, keeping the v3
+ * plugin's load (and its test) free of heavier module graphs. Returns `null`
+ * when absent, empty, or unreadable.
+ */
+function readNowContext(): string | null {
+  const nowPath = getWorkspacePromptPath("NOW.md");
+  if (!existsSync(nowPath)) return null;
+  try {
+    const stripped = stripCommentLines(readFileSync(nowPath, "utf-8")).trim();
+    return stripped.length > 0 ? stripped : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Compose the situational signal threaded into L1 routing and L2 selection: the
+ * current date plus the live NOW.md scratchpad. The date alone is a weak signal,
+ * but together with the scratchpad it lets retrieval surface a leaf the message
+ * never names (e.g. an anniversary that falls today). Always returns at least
+ * the date line — this mirrors the `c_now`/NOW.md signal the v2 retriever uses.
+ */
+function buildSituationalContext(): string {
+  const now = readNowContext();
+  const today = `Today is ${new Date().toDateString()}.`;
+  return now ? `${today}\n\n${now}` : today;
+}
+
 /**
  * Build a v3 {@link TurnContext} from the conversation's persisted messages.
  * `currentMessage` is the latest user message; `recentContext` is the tail of
- * the recent transcript. Returns `null` when there is no user message to route
+ * the recent transcript; `situationalContext` carries the current date and the
+ * live NOW.md scratchpad. Returns `null` when there is no user message to route
  * on (nothing to shadow this turn).
  */
 function buildShadowTurn(
@@ -198,6 +226,7 @@ function buildShadowTurn(
     turnNumber: turnIndex,
     currentMessage,
     recentContext,
+    situationalContext: buildSituationalContext(),
   };
 }
 
@@ -272,7 +301,7 @@ function writeSelections(
  * failures are logged and swallowed (returning `null`) so the live turn is
  * unaffected. Returns `null` when there is no user message to route on.
  */
-async function observeTurn(
+export async function observeTurn(
   conversationId: string,
   turnIndex: number,
 ): Promise<OrchestrateResult | null> {
@@ -280,13 +309,15 @@ async function observeTurn(
     const turn = buildShadowTurn(conversationId, turnIndex);
     if (!turn) return null;
 
-    const lanes = await getLanes(getConfig());
+    const cfg = getConfig();
+    const lanes = await getLanes(cfg);
     const result = await orchestrate(turn, {
       tree: lanes.tree,
       core: lanes.core,
       needle: lanes.needle,
       workingSet: lanes.workingSet,
       pageSummary,
+      l2Concurrency: cfg.memory.v3.l2Concurrency,
     });
 
     const rows = attributeSelections(lanes.tree, lanes.core, result);
@@ -316,64 +347,3 @@ export async function runShadowObservation(
   if (!isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, getConfig())) return;
   await observeTurn(conversationId, turnIndex);
 }
-
-/**
- * The v3 injector. Reads both flags:
- *   - `memory-v3-live` on → orchestrate, log, render the working-set selection
- *     into a `<memory>` block, and return it at v2's dynamic-memory placement.
- *   - `memory-v3-shadow` on (live off) → orchestrate + log only, return `null`.
- *   - both off → return `null` (no orchestration).
- *
- * Empty selection and any failure return `null` (no v3 injection). v2
- * suppression keys off BOTH the flag AND this return value, so a `null` here
- * (failure or empty selection) falls back to v2 memory rather than dropping all
- * memory.
- */
-const memoryV3Injector: Injector = {
-  name: "memory-v3-shadow",
-  // High order so it sorts last; the live `<memory>` block uses the
-  // after-memory-prefix placement so it lands at the memory boundary regardless
-  // of this sort key, which only orders content-producing injectors.
-  order: 1000,
-  async produce(ctx: PluginTurnContext): Promise<InjectionBlock | null> {
-    const config = getConfig();
-    const live = isAssistantFeatureFlagEnabled(MEMORY_V3_LIVE, config);
-    const shadow = isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, config);
-    if (!live && !shadow) return null;
-
-    const result = await observeTurn(ctx.conversationId, ctx.turnIndex);
-    if (!live || !result) return null;
-
-    try {
-      // `renderMemoryBlock` returns "" for an empty selection; inject nothing.
-      const text = await renderMemoryBlock(
-        result.finalInjection,
-        renderV3PageContent,
-      );
-      if (text.length === 0) return null;
-      return {
-        id: MEMORY_V3_BLOCK_ID,
-        text,
-        // Mirror v2's dynamic `<memory>` block placement.
-        placement: "after-memory-prefix",
-      };
-    } catch (err) {
-      log.warn(
-        {
-          err: err instanceof Error ? err.message : String(err),
-          conversationId: ctx.conversationId,
-        },
-        "memory-v3 live render failed (non-fatal) — falling back to v2",
-      );
-      return null;
-    }
-  },
-};
-
-export const memoryV3ShadowPlugin: Plugin = {
-  manifest: {
-    name: "memory-v3-shadow",
-    version: "0.0.1",
-  },
-  injectors: [memoryV3Injector],
-};

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/tree.ts

@@ -5,7 +5,7 @@ import { fileURLToPath } from "node:url";
 
 import { parse as parseYaml } from "yaml";
 
-import { getWorkspaceDir } from "../../util/platform.js";
+import { getWorkspaceDir } from "../../../util/platform.js";
 import type {
   LeafFrontmatter,
   LeafNode,