@vellumai/assistant 0.8.11 → 0.8.12-staging.2

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

@@ -141,14 +141,32 @@ const { CUTOFF_PLACEHOLDER, CONSOLIDATION_PROMPT } =
   await import("../prompts/consolidation.js");
 
 // The handler only reads `config.memory.enabled`, `config.memory.v2.enabled`,
-// and `config.memory.v2.consolidation_prompt_path`, so a minimal stand-in
-// covers those call sites without materializing the full default config.
+// `config.memory.v2.consolidation_prompt_path`, and
+// `config.memory.v2.consolidation_max_entries_per_run`, so a minimal
+// stand-in covers those call sites without materializing the full default
+// config.
 const CONFIG = {
   memory: {
     enabled: true,
     v2: { enabled: true, consolidation_prompt_path: null },
   },
 } as Parameters<typeof memoryV2ConsolidateJob>[1];
+
+/** CONFIG plus a per-run entry cap for the chunked-cutoff tests. */
+function configWithMaxEntries(
+  maxEntries: number | null,
+): Parameters<typeof memoryV2ConsolidateJob>[1] {
+  return {
+    memory: {
+      enabled: true,
+      v2: {
+        enabled: true,
+        consolidation_prompt_path: null,
+        consolidation_max_entries_per_run: maxEntries,
+      },
+    },
+  } as Parameters<typeof memoryV2ConsolidateJob>[1];
+}
 const CONFIG_DISABLED = {
   memory: {
     enabled: true,
@@ -205,6 +223,169 @@ beforeEach(() => {
 
 // ---------------------------------------------------------------------------
 
+describe("memoryV2ConsolidateJob — chunked cutoff (consolidation_max_entries_per_run)", () => {
+  const FIVE_ENTRIES = [
+    "- [Apr 27, 9:00 AM] Alice prefers VS Code.",
+    "- [Apr 27, 9:01 AM] Bob takes his coffee black.",
+    "- [Apr 27, 9:02 AM] Carol loves jazz.",
+    "- [Apr 27, 9:03 AM] Dave runs marathons.",
+    "- [Apr 27, 9:04 AM] Erin paints watercolors.",
+  ].join("\n");
+
+  test("buffer over the cap → cutoff is the first over-cap entry's timestamp; overflow deferred", async () => {
+    writeFileSync(bufferPath(), FIVE_ENTRIES + "\n");
+
+    const outcome = await memoryV2ConsolidateJob(
+      makeJob(),
+      configWithMaxEntries(3),
+    );
+
+    expect(outcome.kind).toBe("invoked");
+    if (outcome.kind !== "invoked") throw new Error("unreachable");
+    expect(outcome.cutoff).toBe("Apr 27, 9:03 AM");
+    expect(outcome.deferredEntries).toBe(2);
+    expect(runnerCalls).toBe(1);
+    expect(runnerLastArgs!.prompt as string).toContain("Apr 27, 9:03 AM");
+  });
+
+  test("buffer at or under the cap → full-buffer cutoff, nothing deferred", async () => {
+    writeFileSync(bufferPath(), FIVE_ENTRIES + "\n");
+
+    const outcome = await memoryV2ConsolidateJob(
+      makeJob(),
+      configWithMaxEntries(5),
+    );
+
+    expect(outcome.kind).toBe("invoked");
+    if (outcome.kind !== "invoked") throw new Error("unreachable");
+    expect(outcome.deferredEntries).toBe(0);
+    // Cutoff is the run-start timestamp, not any buffer entry's.
+    expect(outcome.cutoff).not.toBe("Apr 27, 9:03 AM");
+  });
+
+  test("null cap → full buffer processed regardless of size", async () => {
+    writeFileSync(bufferPath(), FIVE_ENTRIES + "\n");
+
+    const outcome = await memoryV2ConsolidateJob(
+      makeJob(),
+      configWithMaxEntries(null),
+    );
+
+    expect(outcome.kind).toBe("invoked");
+    if (outcome.kind !== "invoked") throw new Error("unreachable");
+    expect(outcome.deferredEntries).toBe(0);
+  });
+
+  test("cap absent from config (hand-crafted stand-in) → full buffer processed", async () => {
+    writeFileSync(bufferPath(), FIVE_ENTRIES + "\n");
+
+    const outcome = await memoryV2ConsolidateJob(makeJob(), CONFIG);
+
+    expect(outcome.kind).toBe("invoked");
+    if (outcome.kind !== "invoked") throw new Error("unreachable");
+    expect(outcome.deferredEntries).toBe(0);
+  });
+
+  test("same-minute burst (every entry shares the over-cap timestamp) → full-buffer cutoff, no wedge", () => {
+    // A sweep that wrote >cap entries within one minute: a pulled-back
+    // cutoff would defer ALL of them ("timestamp >= cutoff stays") and the
+    // size trigger would requeue an identical no-op run forever.
+    writeFileSync(
+      bufferPath(),
+      [
+        "- [Apr 27, 9:00 AM] Alice prefers VS Code.",
+        "- [Apr 27, 9:00 AM] Bob takes his coffee black.",
+        "- [Apr 27, 9:00 AM] Carol loves jazz.",
+        "- [Apr 27, 9:00 AM] Dave runs marathons.",
+      ].join("\n") + "\n",
+    );
+
+    return memoryV2ConsolidateJob(makeJob(), configWithMaxEntries(2)).then(
+      (outcome) => {
+        expect(outcome.kind).toBe("invoked");
+        if (outcome.kind !== "invoked") throw new Error("unreachable");
+        expect(outcome.deferredEntries).toBe(0);
+        expect(outcome.cutoff).not.toBe("Apr 27, 9:00 AM");
+      },
+    );
+  });
+
+  test("continuation lines (multi-line entries) don't count as entries or break the cutoff", async () => {
+    // The second entry carries embedded newlines: its continuation lines
+    // belong to that entry, so the buffer holds 3 entries, not 5 lines.
+    // With a cap of 2, the cutoff is the THIRD entry's timestamp.
+    writeFileSync(
+      bufferPath(),
+      [
+        "- [Apr 27, 9:00 AM] Alice prefers VS Code.",
+        "- [Apr 27, 9:01 AM] Bob shared a snippet:",
+        "  line two of Bob's multi-line memory",
+        "  line three of Bob's multi-line memory",
+        "- [Apr 27, 9:03 AM] Dave runs marathons.",
+      ].join("\n") + "\n",
+    );
+
+    const outcome = await memoryV2ConsolidateJob(
+      makeJob(),
+      configWithMaxEntries(2),
+    );
+
+    expect(outcome.kind).toBe("invoked");
+    if (outcome.kind !== "invoked") throw new Error("unreachable");
+    expect(outcome.cutoff).toBe("Apr 27, 9:03 AM");
+    expect(outcome.deferredEntries).toBe(1);
+  });
+
+  test("bracketed continuation lines (checklists, wikilinks) are not counted as entries", async () => {
+    // Continuation lines that START with "- [" but don't carry the
+    // formatBufferTimestamp shape must not count toward the cap or become
+    // the cutoff — "- [ ] task" would otherwise yield a blank-string cutoff.
+    writeFileSync(
+      bufferPath(),
+      [
+        "- [Apr 27, 9:00 AM] Alice's project plan:",
+        "- [ ] follow up with Bob",
+        "- [[meeting-notes]] referenced doc",
+        "- [Apr 27, 9:01 AM] Carol loves jazz.",
+      ].join("\n") + "\n",
+    );
+
+    const outcome = await memoryV2ConsolidateJob(
+      makeJob(),
+      configWithMaxEntries(2),
+    );
+
+    expect(outcome.kind).toBe("invoked");
+    if (outcome.kind !== "invoked") throw new Error("unreachable");
+    // Two real entries, cap 2 → no chunking, full-buffer cutoff.
+    expect(outcome.deferredEntries).toBe(0);
+    expect(outcome.cutoff).not.toBe(" ");
+    expect(outcome.cutoff).not.toBe("[meeting-notes]");
+  });
+
+  test("multi-line entries under the cap → full-buffer cutoff even when raw line count exceeds it", async () => {
+    writeFileSync(
+      bufferPath(),
+      [
+        "- [Apr 27, 9:00 AM] Alice shared a snippet:",
+        "  continuation one",
+        "  continuation two",
+        "- [Apr 27, 9:01 AM] Bob takes his coffee black.",
+      ].join("\n") + "\n",
+    );
+
+    const outcome = await memoryV2ConsolidateJob(
+      makeJob(),
+      configWithMaxEntries(2),
+    );
+
+    expect(outcome.kind).toBe("invoked");
+    if (outcome.kind !== "invoked") throw new Error("unreachable");
+    expect(outcome.deferredEntries).toBe(0);
+    expect(outcome.cutoff).not.toBe("Apr 27, 9:01 AM");
+  });
+});
+
 describe("memoryV2ConsolidateJob — v2 disabled", () => {
   test("returns disabled without invoking the runner when memory.enabled is false", async () => {
     writeFileSync(bufferPath(), "- [Apr 27, 9:00 AM] Alice prefers VS Code.\n");

package/src/memory/v2/__tests__/injection.test.ts

@@ -1872,6 +1872,76 @@ describe("injectMemoryV2Block", () => {
       expect(aliceRow!.ownActivation).toBe(0);
     });
 
+    test("flag-on: saturated index (every page already injected) skips the router LLM call", async () => {
+      // Turn 1 — normal router path injects alice.
+      routerState.nextResult = {
+        selectedSlugs: ["alice-vscode"],
+        failureReason: null,
+      };
+      await injectMemoryV2Block({
+        database: db,
+        conversationId: "conv-router-saturated",
+        currentTurn: 1,
+        recentTurnPairs: [
+          { assistantMessage: "", userMessage: "Tell me about Alice" },
+        ],
+        nowText: "Now",
+        messageId: "msg-1",
+        config: makeConfig({ router: { enabled: true } }),
+      });
+
+      // Mark every page in the index as already injected — the state a
+      // small workspace reaches a few turns into any conversation.
+      const { getPageIndex } = await import("../page-index.js");
+      const index = await getPageIndex(tmpWorkspace);
+      const seeded = await hydrate(db, "conv-router-saturated");
+      await save(db, "conv-router-saturated", {
+        ...seeded!,
+        everInjected: index.entries.map((e) => ({ slug: e.slug, turn: 1 })),
+      });
+
+      // Turn 2 — the router must not be called: any selection would dedupe
+      // against everInjected and render nothing.
+      const callsBefore = routerState.callCount;
+      routerState.nextResult = {
+        selectedSlugs: ["bob-coffee"],
+        failureReason: null,
+      };
+      const result = await injectMemoryV2Block({
+        database: db,
+        conversationId: "conv-router-saturated",
+        currentTurn: 2,
+        recentTurnPairs: [{ assistantMessage: "ok", userMessage: "and Bob?" }],
+        nowText: "Now",
+        messageId: "msg-2",
+        config: makeConfig({ router: { enabled: true } }),
+      });
+
+      expect(routerState.callCount).toBe(callsBefore);
+      expect(result.block).toBeNull();
+      expect(result.toInject).toEqual([]);
+
+      // State still advanced; everInjected preserved for future dedupe.
+      const persisted = await hydrate(db, "conv-router-saturated");
+      expect(persisted!.currentTurn).toBe(2);
+      expect(persisted!.messageId).toBe("msg-2");
+      expect(persisted!.everInjected.length).toBe(index.entries.length);
+
+      // Telemetry row stays in router mode with every slug carried over.
+      const row = telemetryState.recordCalls.at(-1) as {
+        mode: string;
+        concepts: Array<{ source: string; status: string }>;
+      };
+      expect(row.mode).toBe("router");
+      expect(row.concepts.length).toBe(index.entries.length);
+      for (const concept of row.concepts) {
+        expect(concept.source).toBe("carry_over");
+        // `finalizeInjection` rewrites the placeholder status: slugs already
+        // in everInjected are reported as in_context.
+        expect(concept.status).toBe("in_context");
+      }
+    });
+
     test("flag-on: router failure logs warn, writes mode:`errored` telemetry, returns null block", async () => {
       routerState.nextResult = {
         selectedSlugs: [],

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

@@ -126,6 +126,18 @@ describe("readMemoryV2StaticContent", () => {
     expect(text.indexOf("## Recent")).toBeLessThan(text.indexOf("## Buffer"));
   });
 
+  test("excludeBuffer drops the Buffer section but keeps the other three", () => {
+    for (const file of MEMORY_FILES) writeMemoryFile(file, `Content ${file}`);
+
+    const result = readMemoryV2StaticContent({ excludeBuffer: true });
+    expect(result).not.toBeNull();
+    expect(result!).toContain("## Essentials");
+    expect(result!).toContain("## Threads");
+    expect(result!).toContain("## Recent");
+    expect(result!).not.toContain("## Buffer");
+    expect(result!).not.toContain("Content buffer.md");
+  });
+
   test("omits empty files but keeps populated ones", () => {
     writeMemoryFile("essentials.md", "Alice prefers VS Code.");
     writeMemoryFile("threads.md", "");

package/src/memory/v2/consolidation-job.ts

@@ -144,6 +144,12 @@ export type ConsolidationOutcome =
       kind: "invoked";
       conversationId: string;
       cutoff: string;
+      /**
+       * Buffer entries beyond `consolidation_max_entries_per_run` left for a
+       * follow-up pass via the pulled-back cutoff. `0` when the whole buffer
+       * fit in one run.
+       */
+      deferredEntries: number;
       followUpJobIds: string[];
     };
 
@@ -174,15 +180,7 @@ export async function memoryV2ConsolidateJob(
   }
 
   try {
-    // Step 2: capture cutoff. Formatted to match `buffer.md` entry timestamps
-    // (`Mon D, h:mm AM/PM`, see `formatBufferTimestamp`) so the agent's
-    // "timestamp ≥ cutoff" check compares like-with-like at minute precision.
-    // Same-minute entries land on the next pass — conservative but loss-free.
-    // Captured here (not at enqueue time) so late-claimed rows get a fresh
-    // cutoff.
-    const cutoff = formatBufferTimestamp(new Date());
-
-    // Step 3: bail on empty buffer. Nothing for the agent to consolidate.
+    // Step 2: bail on empty buffer. Nothing for the agent to consolidate.
     // The lock is released in finally below.
     const bufferContent = readBufferContent(bufferPath);
     if (bufferContent.trim().length === 0) {
@@ -190,6 +188,68 @@ export async function memoryV2ConsolidateJob(
       return { kind: "empty_buffer" };
     }
 
+    // Step 3: capture cutoff. Formatted to match `buffer.md` entry timestamps
+    // (`Mon D, h:mm AM/PM`, see `formatBufferTimestamp`) so the agent's
+    // "timestamp ≥ cutoff" check compares like-with-like at minute precision.
+    // Same-minute entries land on the next pass — conservative but loss-free.
+    // Captured here (not at enqueue time) so late-claimed rows get a fresh
+    // cutoff.
+    //
+    // Chunking: when the buffer holds more than
+    // `consolidation_max_entries_per_run` entries (a backlog from missed or
+    // failed runs), pull the cutoff back to the first over-cap entry's
+    // timestamp. The agent's existing "≥ cutoff stays" rule then defers the
+    // overflow loss-free, and the `consolidation_max_buffer_lines` size
+    // trigger re-fires while the remainder stays over threshold — so one run
+    // never has to read an unbounded backlog into context. Entries sharing
+    // the over-cap entry's minute are also deferred (conservative).
+    //
+    // Entries are counted by their timestamped bullet-start lines
+    // (`- [Mon D, h:mm AM/PM] …`) rather than raw non-empty lines: a
+    // remembered fact can carry embedded newlines, and its continuation
+    // lines belong to the preceding entry, not the count.
+    let cutoff = formatBufferTimestamp(new Date());
+    let deferredEntries = 0;
+    const maxEntries = config.memory.v2.consolidation_max_entries_per_run;
+    if (maxEntries != null) {
+      const entryTimestamps = bufferContent
+        .split("\n")
+        .map(extractBufferEntryTimestamp)
+        .filter((timestamp): timestamp is string => timestamp !== null);
+      if (entryTimestamps.length > maxEntries) {
+        const overflowTimestamp = entryTimestamps[maxEntries];
+        // Same-minute burst guard: timestamps have minute precision, so when
+        // even the FIRST entry shares the over-cap entry's timestamp, a
+        // pulled-back cutoff would tell the agent to defer every entry
+        // ("timestamp ≥ cutoff stays") — zero progress, and the size trigger
+        // would requeue the identical run forever. Fall back to the
+        // full-buffer cutoff in that case; partial same-minute runs (some
+        // earlier entries have older timestamps) still make progress.
+        if (entryTimestamps[0] === overflowTimestamp) {
+          log.warn(
+            {
+              bufferEntries: entryTimestamps.length,
+              maxEntries,
+              overflowTimestamp,
+            },
+            "consolidation: entire over-cap prefix shares one minute timestamp; processing full buffer to guarantee progress",
+          );
+        } else {
+          cutoff = overflowTimestamp;
+          deferredEntries = entryTimestamps.length - maxEntries;
+          log.info(
+            {
+              bufferEntries: entryTimestamps.length,
+              maxEntries,
+              deferredEntries,
+              cutoff,
+            },
+            "consolidation chunked: buffer over per-run cap, overflow deferred to next pass",
+          );
+        }
+      }
+    }
+
     // Step 4: hand off to the centralized background-job runner. The runner
     // bootstraps the conversation, drives `processMessage`, applies the
     // timeout policy, classifies errors, and — because we opt out via
@@ -225,6 +285,7 @@ export async function memoryV2ConsolidateJob(
       jobName: JOB_NAME,
       source: MEMORY_V2_CONSOLIDATION_SOURCE,
       prompt,
+      systemHint: "Memory consolidation",
       trustContext: { sourceChannel: "vellum", trustClass: "guardian" },
       callSite: "memoryV2Consolidation",
       timeoutMs: CONSOLIDATION_TIMEOUT_MS,
@@ -272,6 +333,7 @@ export async function memoryV2ConsolidateJob(
       {
         conversationId: runResult.conversationId,
         cutoff,
+        deferredEntries,
         followUpJobIds,
       },
       "consolidation invoked",
@@ -280,6 +342,7 @@ export async function memoryV2ConsolidateJob(
       kind: "invoked",
       conversationId: runResult.conversationId,
       cutoff,
+      deferredEntries,
       followUpJobIds,
     };
   } finally {
@@ -300,6 +363,27 @@ function readBufferContent(bufferPath: string): string {
   }
 }
 
+/**
+ * Extract the bracketed timestamp from a `buffer.md` entry line
+ * (`- [Mon D, h:mm AM/PM] …`, see `formatBufferEntry`). Returned verbatim so
+ * it can serve directly as a consolidation cutoff — both sides of the agent's
+ * "timestamp ≥ cutoff" comparison then share the exact `formatBufferTimestamp`
+ * shape.
+ *
+ * The bracket contents must match that shape exactly: a remembered fact's
+ * continuation lines can themselves start with `- [` (markdown checklists
+ * `- [ ] …`, wikilink bullets `- [[…]]`), and counting those as entries
+ * would inflate the per-run budget — or worse, hand the agent a garbage
+ * cutoff like a blank string. Returns `null` for anything that isn't a real
+ * timestamped entry start.
+ */
+function extractBufferEntryTimestamp(line: string): string | null {
+  const match = /^\s*-\s*\[([A-Z][a-z]{2} \d{1,2}, \d{1,2}:\d{2} [AP]M)\]/.exec(
+    line,
+  );
+  return match ? match[1] : null;
+}
+
 /**
  * Count non-empty lines in `memory/buffer.md`. Used by the scheduler to
  * implement the size-based consolidation trigger. Missing file → 0.

package/src/memory/v2/injection.ts

@@ -44,6 +44,7 @@ import {
 } from "./cli-command-store.js";
 import { getEdgeIndex } from "./edge-index.js";
 import { recordInjectionEvents } from "./injection-events.js";
+import { getPageIndex } from "./page-index.js";
 import { readPage, renderPageContent } from "./page-store.js";
 import { type RouterTurnPair, runRouter } from "./router.js";
 import { getSkillCapability, isSkillSlug } from "./skill-store.js";
@@ -553,6 +554,58 @@ async function injectViaRouter(args: {
   const priorEverInjected: readonly EverInjectedEntry[] =
     priorState?.everInjected ?? [];
 
+  // Saturated-index bypass: when every page in the index has already been
+  // injected on a prior turn of this conversation, the router LLM call is
+  // provably useless — whatever it selected would be deduped against
+  // `priorEverInjected` below and render nothing. Small workspaces reach
+  // this state within the first few turns, after which the per-message
+  // router call is pure cost. Skip the call and finalize directly with
+  // carry-over telemetry, mirroring the success path's "all selections
+  // already injected" outcome. (Trade-off: re-pick EMA events are not
+  // recorded from this state; with the whole index attached, injection-
+  // score ranking has nothing left to decide for this conversation.)
+  const everInjectedSlugSet = new Set(priorEverInjected.map((e) => e.slug));
+  const pageIndexForBypass = await getPageIndex(workspaceDir);
+  if (
+    pageIndexForBypass.entries.length > 0 &&
+    pageIndexForBypass.entries.every((e) => everInjectedSlugSet.has(e.slug))
+  ) {
+    log.info(
+      {
+        conversationId,
+        indexSize: pageIndexForBypass.entries.length,
+      },
+      "memory v2 router skipped — every index page already injected",
+    );
+    return finalizeInjection({
+      workspaceDir,
+      database,
+      conversationId,
+      mode: "router",
+      currentTurn,
+      messageId,
+      priorEverInjected,
+      slugsToRender: [],
+      telemetryRows: priorEverInjected.map((entry) => ({
+        slug: entry.slug,
+        finalActivation: 0,
+        ownActivation: 0,
+        priorActivation: 0,
+        simUser: 0,
+        simAssistant: 0,
+        simNow: 0,
+        simUserRerankBoost: 0,
+        simAssistantRerankBoost: 0,
+        inRerankPool: false,
+        spreadContribution: 0,
+        source: "carry_over",
+        status: "not_injected",
+      })),
+      config,
+      nextStateMap: {},
+    });
+  }
+
   const routerResult = await runRouter({
     workspaceDir,
     recentTurnPairs,

package/src/memory/v2/prompts/consolidation.ts

@@ -571,6 +571,7 @@ Bullets where a list is genuinely a list.
 - **\`links\`** are directed see-also references, each annotated: \`"target-slug — why"\`. The annotation is for future-you deciding whether to follow it. Directed means listing B here pulls B toward A's readers — it does not link back.
 - **\`tags\`** are flat labels for the cluster(s) this touches. Index pages also carry \`kind: index\`.
 - **No \`summary:\` field.** The lead is the summary. Writing a good lead IS writing the retrieval surface.
+- **\`current:\`** — optional ONE-LINE live state of the page's subject: open items, deadlines, what's owed or pending, with an as-of date in the text (\`current: "bridge check owed before thursday's dry-run (as of jun 10)"\`). Retrieval renders it on the card, so status-shaped questions ("what's on my plate", "what's pending") can find the page. Maintain it like state, not prose: update it when the state moves, DELETE the field the moment nothing is live — a stale \`current:\` is worse than none. Most pages never carry one. \`threads.md\` remains the cross-page commitments list; \`current:\` is per-page state, not a second threads file.
 
 ## The card budget (the economic principle)
 

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

@@ -38,8 +38,17 @@ const MEMORY_V2_STATIC_BLOCKS: readonly MemoryV2StaticBlock[] = [
  * Build the v2 static memory block, gated on `config.memory.enabled` and
  * `config.memory.v2.enabled`. Empty/missing files are skipped; returns `null`
  * when either gate is off or every file is empty.
+ *
+ * `excludeBuffer` drops the `## Buffer` section. The consolidation run sets
+ * it: the agent's contract there is the `memory/buffer.md` FILE — it reads,
+ * routes, and rewrites it through file tools — so injecting a static snapshot
+ * of the same content would duplicate the entire (potentially unbounded)
+ * backlog into the turn's context and go stale the moment the agent edits
+ * the file.
  */
-export function readMemoryV2StaticContent(): string | null {
+export function readMemoryV2StaticContent(
+  options: { excludeBuffer?: boolean } = {},
+): string | null {
   let config;
   try {
     config = loadConfig();
@@ -52,6 +61,9 @@ export function readMemoryV2StaticContent(): string | null {
 
   const sections: string[] = [];
   for (const { heading, file } of MEMORY_V2_STATIC_BLOCKS) {
+    if (options.excludeBuffer === true && file === "memory/buffer.md") {
+      continue;
+    }
     const content = readPromptFile(getWorkspacePromptPath(file));
     if (!content) continue;
     sections.push(`${heading}\n\n${content}`);

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

@@ -283,7 +283,7 @@ function loadRecentMessagesText(nowMs: number): string {
   // initial limit (1000) defends against pathological busy windows where a
   // naive scan would touch every recent message. Joining conversations and
   // excluding background/scheduled types keeps automation chatter
-  // (heartbeats, filing, update bulletins, scheduled jobs) out of buffer.md.
+  // (heartbeats, filing, scheduled jobs) out of buffer.md.
   const rows = db
     .select({
       role: messages.role,

package/src/memory/v2/types.ts

@@ -62,6 +62,11 @@ export const ConceptPageFrontmatterSchema = z
     main: z.string().optional(),
     kind: z.string().optional(),
     status: z.string().optional(),
+    // One-line live state of the page's subject (open items, deadlines,
+    // what's pending), as-of dated by convention. Memory-v3 renders it on the
+    // card surface so state-shaped questions can select the page. Distinct
+    // from `status:` (the article-model draft marker, e.g. "cc-draft").
+    current: z.string().optional(),
   })
   .strict();
 

package/src/plugin-api/types.ts

@@ -314,6 +314,13 @@ export interface PostToolUseContext {
    * singular of Codex's `additional_contexts`. `null` means no extra context.
    */
   additionalContext: string | null;
+  /**
+   * Model id reported by the provider for the assistant turn that issued
+   * this tool call (e.g. `claude-opus-4-8`,
+   * `accounts/fireworks/models/kimi-k2p6`). Hooks use it to vary coaching by
+   * model family — some models need earlier or firmer steering than others.
+   */
+  readonly model: string;
   /**
    * The model's context-window size in tokens. Plugins derive their own
    * character budget from this (e.g. a share of the window) rather than