@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091853.fbaa2ae

package/src/memory/v3/maintain-job.ts

@@ -1,314 +0,0 @@
-/**
- * Memory v3 — `memory_v3_maintain` job handler.
- *
- * A flag-gated, best-effort self-maintenance pass over the v3 topic tree and
- * its page→leaf assignments. It runs three independent stages, in order:
- *
- *   1. **Classify-union** — `assignPages` over the delta: every page that is
- *      still unassigned (empty `leaves:`) plus every page edited since the last
- *      successful pass (the high-water mark below), UNIONing freshly classified
- *      leaves into each page (never dropping existing picks). Re-touching
- *      already-assigned-but-recently-edited pages lets the classifier enrich the
- *      assistant's own in-consolidation labels with any leaves it missed.
- *   2. **Prune** — drop any frontmatter `leaves:` entry that points at a leaf
- *      path no longer present in the tree (dangling references left behind when
- *      a leaf is renamed or removed). Read + rewrite only the affected pages.
- *   3. **Needle rebuild** — `invalidateLanes()` so the next turn rebuilds the
- *      leaf tree and BM25 needle from the freshly-updated assignments.
- *
- * Best-effort by construction: each stage is wrapped so a failure in one is
- * logged and recorded in the outcome but does NOT abort the others. The job is
- * a no-op (returns a disabled outcome) unless `memory-v3-shadow` OR
- * `memory-v3-live` is enabled — the same flags that gate the v3 plugin.
- *
- * Dependency-injectable: `deps` lets tests substitute the tree loader,
- * `assignPages`, and `invalidateLanes` without process-global module mocks.
- */
-
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
-import type { AssistantConfig } from "../../config/types.js";
-import { getLogger } from "../../util/logger.js";
-import { getWorkspaceDir } from "../../util/platform.js";
-import { getMemoryCheckpoint, setMemoryCheckpoint } from "../checkpoints.js";
-import type { MemoryJob } from "../jobs-store.js";
-import { getPageIndex } from "../v2/page-index.js";
-import { listPages, readPage, writePage } from "../v2/page-store.js";
-import { assignPages as realAssignPages } from "./assign.js";
-import { invalidateLanes as realInvalidateLanes } from "./shadow-plugin.js";
-import { loadLeafTree as realLoadLeafTree, resolveDataDir } from "./tree.js";
-import type { LeafPath, LeafTree, Slug } from "./types.js";
-
-const MEMORY_V3_SHADOW = "memory-v3-shadow" as const;
-const MEMORY_V3_LIVE = "memory-v3-live" as const;
-
-/**
- * Durable checkpoint holding the epoch-ms high-water mark of the last successful
- * classify-union pass. Pages whose mtime is past this mark are re-classified
- * (enrichment); the mark is advanced only after a pass completes, captured after
- * its writes so the pass's own frontmatter rewrites do not re-trigger it.
- * Distinct from `memory_v3_maintain_last_run` (the enqueue-cadence checkpoint in
- * `jobs-worker.ts`), which advances on every backstop enqueue rather than on an
- * actual maintenance run.
- */
-const MAINTAIN_ENRICH_HIGH_WATER_KEY =
-  "memory_v3_maintain:enriched_through_ms" as const;
-
-const log = getLogger("memory-v3-maintain");
-
-/** Injectable collaborators; defaults wire the real implementations. */
-export interface MaintainJobDeps {
-  /** Load the v3 leaf tree (page→leaf membership resolved from frontmatter). */
-  loadTree: () => Promise<LeafTree>;
-  /** Classify-union pass over pages. */
-  assignPages: typeof realAssignPages;
-  /**
-   * The slugs to classify this pass: unassigned pages plus pages edited since
-   * the last successful pass. See {@link computeClassifyTargets}.
-   */
-  selectClassifyTargets: () => Promise<Slug[]>;
-  /**
-   * Persist the enrichment high-water mark after a successful classify pass. The
-   * value is captured after the pass's writes (see the key docstring).
-   */
-  commitClassifyHighWater: (highWaterMs: number) => void;
-  /** Drop the memoized v3 lanes so the next turn rebuilds tree + needle. */
-  invalidateLanes: () => void;
-  /** Workspace root; pages live under `<workspaceDir>/memory/concepts/`. */
-  workspaceDir: string;
-}
-
-/** Per-stage outcome surfaced in the structured log line. */
-export interface MaintainOutcome {
-  /** True when both v3 flags were off and the job no-opped. */
-  disabled: boolean;
-  /** Pages newly assigned by the classify-union stage. */
-  assigned: number;
-  /** Pages whose dangling refs were pruned. */
-  pruned: number;
-  /** Dangling leaf references dropped across all pruned pages. */
-  prunedRefs: number;
-  /** Whether the needle/tree lanes were invalidated. */
-  invalidated: boolean;
-  /** Stages that threw (and were contained). */
-  failures: string[];
-}
-
-/**
- * Load the v3 leaf tree the same way the live plugin does: resolve the data
- * dir, build the page→leaf membership map from the page index frontmatter, and
- * hand both to `loadLeafTree`.
- */
-async function loadTreeFromWorkspace(workspaceDir: string): Promise<LeafTree> {
-  const pageIndex = await getPageIndex(workspaceDir);
-  const pageLeaves = new Map<Slug, LeafPath[]>();
-  for (const entry of pageIndex.entries) {
-    pageLeaves.set(entry.slug, entry.leaves);
-  }
-  return realLoadLeafTree(resolveDataDir(), pageLeaves);
-}
-
-/** Page-index projection the classify-target selector reads. */
-export interface ClassifyCandidate {
-  slug: Slug;
-  /** File mtime in epoch ms; 0 for synthetic skill/CLI rows (excluded). */
-  modifiedAt: number;
-  /** Leaf assignments from frontmatter; `[]` when unassigned. */
-  leaves: LeafPath[];
-}
-
-/**
- * Pick the pages the classify-union stage should run this pass:
- *
- *  - **Unassigned** pages (empty `leaves:`) — always classified so a page is
- *    never left permanently unrouted (the pre-enrichment behavior).
- *  - **Recently edited** pages (mtime past `prevHighWaterMs`) — even when
- *    already assigned, so the classifier can enrich the assistant's own
- *    in-consolidation labels with leaves it missed. `assignPages` UNIONs, so a
- *    page's existing picks are never dropped — only added to.
- *
- * Synthetic skill/CLI rows (`modifiedAt === 0`) are excluded: they are
- * capability entries, not topic-tree pages. On the first run (`prevHighWaterMs`
- * null) the recency arm is disabled, so a fresh or freshly-backfilled install
- * does a single unassigned-only pass instead of re-classifying the whole corpus.
- */
-export function computeClassifyTargets(
-  pages: ReadonlyArray<ClassifyCandidate>,
-  prevHighWaterMs: number | null,
-): Slug[] {
-  const targets: Slug[] = [];
-  for (const page of pages) {
-    if (page.modifiedAt <= 0) continue; // synthetic capability row
-    const unassigned = page.leaves.length === 0;
-    const recentlyEdited =
-      prevHighWaterMs !== null && page.modifiedAt > prevHighWaterMs;
-    if (unassigned || recentlyEdited) targets.push(page.slug);
-  }
-  return targets;
-}
-
-/** Read the persisted high-water mark, treating missing/garbage as first-run. */
-function readClassifyHighWater(): number | null {
-  const raw = getMemoryCheckpoint(MAINTAIN_ENRICH_HIGH_WATER_KEY);
-  if (raw === null) return null;
-  const parsed = Number.parseInt(raw, 10);
-  return Number.isNaN(parsed) ? null : parsed;
-}
-
-/** Default target selector: page index → {@link computeClassifyTargets}. */
-async function selectClassifyTargetsFromWorkspace(
-  workspaceDir: string,
-): Promise<Slug[]> {
-  const index = await getPageIndex(workspaceDir);
-  return computeClassifyTargets(index.entries, readClassifyHighWater());
-}
-
-function commitClassifyHighWater(highWaterMs: number): void {
-  setMemoryCheckpoint(MAINTAIN_ENRICH_HIGH_WATER_KEY, String(highWaterMs));
-}
-
-function defaultDeps(): MaintainJobDeps {
-  const workspaceDir = getWorkspaceDir();
-  return {
-    loadTree: () => loadTreeFromWorkspace(workspaceDir),
-    assignPages: realAssignPages,
-    selectClassifyTargets: () =>
-      selectClassifyTargetsFromWorkspace(workspaceDir),
-    commitClassifyHighWater,
-    invalidateLanes: realInvalidateLanes,
-    workspaceDir,
-  };
-}
-
-/**
- * Prune dangling `leaves:` references: for every page, drop frontmatter leaf
- * paths that are not present in `tree`. Read + rewrite only pages that actually
- * change. Returns the number of pages rewritten and total refs dropped.
- */
-async function prunePages(
-  tree: LeafTree,
-  workspaceDir: string,
-): Promise<{ pruned: number; prunedRefs: number }> {
-  const validLeaves = tree.leaves;
-  const slugs = await listPages(workspaceDir);
-  let pruned = 0;
-  let prunedRefs = 0;
-  for (const slug of slugs) {
-    const page = await readPage(workspaceDir, slug);
-    const leaves = page?.frontmatter.leaves;
-    if (!page || !leaves || leaves.length === 0) continue;
-    const kept = leaves.filter((leaf) => validLeaves.has(leaf));
-    if (kept.length === leaves.length) continue;
-    prunedRefs += leaves.length - kept.length;
-    pruned += 1;
-    await writePage(workspaceDir, {
-      ...page,
-      frontmatter: { ...page.frontmatter, leaves: kept },
-    });
-  }
-  return { pruned, prunedRefs };
-}
-
-/**
- * Run the v3 self-maintenance pass. Each stage is independently contained: a
- * thrown error is logged and recorded in `failures` without aborting the rest.
- * No-ops when both v3 flags are off.
- */
-export async function maintainJob(
-  _job: MemoryJob,
-  config: AssistantConfig,
-  deps: MaintainJobDeps = defaultDeps(),
-): Promise<MaintainOutcome> {
-  const outcome: MaintainOutcome = {
-    disabled: false,
-    assigned: 0,
-    pruned: 0,
-    prunedRefs: 0,
-    invalidated: false,
-    failures: [],
-  };
-
-  const enabled =
-    isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, config) ||
-    isAssistantFeatureFlagEnabled(MEMORY_V3_LIVE, config);
-  if (!enabled) {
-    outcome.disabled = true;
-    return outcome;
-  }
-
-  // The tree is shared input for both the assign and prune stages. If it can't
-  // load, those two stages are skipped (recorded as a failure), but we still
-  // invalidate the lanes so a transient load error doesn't wedge the next turn.
-  let tree: LeafTree | null = null;
-  try {
-    tree = await deps.loadTree();
-  } catch (err) {
-    outcome.failures.push("load_tree");
-    log.warn(
-      { err: err instanceof Error ? err.message : String(err) },
-      "memory-v3 maintain: tree load failed (non-fatal)",
-    );
-  }
-
-  if (tree) {
-    // Stage 1: classify-union over the delta (unassigned ∪ recently-edited).
-    try {
-      const targets = await deps.selectClassifyTargets();
-      const results = await deps.assignPages({
-        tree,
-        workspaceDir: deps.workspaceDir,
-        slugs: targets,
-      });
-      outcome.assigned = results.filter(
-        (r) => !r.failed && r.after.length > r.before.length,
-      ).length;
-      // Advance the high-water mark only on success, captured AFTER the writes
-      // above so pages this pass just rewrote (mtime now bumped) sit at-or-below
-      // the mark and do not re-trigger themselves next pass.
-      deps.commitClassifyHighWater(Date.now());
-    } catch (err) {
-      outcome.failures.push("assign");
-      log.warn(
-        { err: err instanceof Error ? err.message : String(err) },
-        "memory-v3 maintain: classify-union failed (non-fatal)",
-      );
-    }
-
-    // Stage 2: prune dangling refs.
-    try {
-      const { pruned, prunedRefs } = await prunePages(tree, deps.workspaceDir);
-      outcome.pruned = pruned;
-      outcome.prunedRefs = prunedRefs;
-    } catch (err) {
-      outcome.failures.push("prune");
-      log.warn(
-        { err: err instanceof Error ? err.message : String(err) },
-        "memory-v3 maintain: prune failed (non-fatal)",
-      );
-    }
-  }
-
-  // Stage 3: rebuild tree + needle on the next turn.
-  try {
-    deps.invalidateLanes();
-    outcome.invalidated = true;
-  } catch (err) {
-    outcome.failures.push("invalidate");
-    log.warn(
-      { err: err instanceof Error ? err.message : String(err) },
-      "memory-v3 maintain: lane invalidation failed (non-fatal)",
-    );
-  }
-
-  log.info(
-    {
-      assigned: outcome.assigned,
-      pruned: outcome.pruned,
-      prunedRefs: outcome.prunedRefs,
-      invalidated: outcome.invalidated,
-      failures: outcome.failures,
-    },
-    "memory-v3 maintain pass complete",
-  );
-
-  return outcome;
-}

package/src/memory/v3/needle.ts

@@ -1,115 +0,0 @@
-import type { LeafTree, Slug } from "./types.js";
-
-/**
- * Sparse "needle" arm for memory-v3 routing: a lexical BM25 search over page
- * titles, slug tokens, summaries, and the labels of the leaves each page
- * belongs to. It augments topical (tree) routing by surfacing pages that share
- * a literal term with the query even when topical routing would miss them.
- *
- * Implementation notes:
- * - Hand-rolled Okapi BM25 (no dependency). The corpus is bounded (one doc per
- *   page), so a plain inverted index is plenty.
- * - The index is built once and held in memory. The orchestrator/plugin
- *   lazy-inits it. Rebuilding on consolidation is a documented fast-follow and
- *   intentionally out of scope here.
- */
-
-/** Okapi BM25 term-frequency saturation parameter. */
-export const k1 = 1.5;
-/** Okapi BM25 length-normalization parameter. */
-export const b = 0.75;
-
-export interface NeedleIndex {
-  /** Returns up to `k` slugs ranked by BM25 score (descending, ties by slug). */
-  query(text: string, k: number): Slug[];
-}
-
-/** Lowercase, split on non-alphanumeric, drop empties. */
-function tokenize(text: string): string[] {
-  return text
-    .toLowerCase()
-    .split(/[^a-z0-9]+/)
-    .filter((token) => token.length > 0);
-}
-
-interface Posting {
-  doc: number;
-  tf: number;
-}
-
-export async function buildNeedleIndex(
-  tree: LeafTree,
-  pageSummary: (slug: Slug) => Promise<string>,
-): Promise<NeedleIndex> {
-  const slugs: Slug[] = [...tree.byPage.keys()];
-
-  // term -> postings (doc index + term frequency in that doc)
-  const postings = new Map<string, Posting[]>();
-  const docLengths: number[] = new Array(slugs.length).fill(0);
-  let totalLength = 0;
-
-  for (let doc = 0; doc < slugs.length; doc++) {
-    const slug = slugs[doc]!;
-
-    // Title = last path segment of the slug; also index the slug tokens.
-    const segments = slug.split(/[/.]/);
-    const title = segments[segments.length - 1] ?? "";
-
-    const parts: string[] = [title, slug, await pageSummary(slug)];
-
-    for (const leafPath of tree.byPage.get(slug) ?? []) {
-      const leaf = tree.leaves.get(leafPath);
-      if (leaf) parts.push(leaf.description);
-    }
-
-    const tokens = tokenize(parts.join(" "));
-    docLengths[doc] = tokens.length;
-    totalLength += tokens.length;
-
-    const termFreqs = new Map<string, number>();
-    for (const token of tokens) {
-      termFreqs.set(token, (termFreqs.get(token) ?? 0) + 1);
-    }
-    for (const [term, tf] of termFreqs) {
-      let list = postings.get(term);
-      if (!list) {
-        list = [];
-        postings.set(term, list);
-      }
-      list.push({ doc, tf });
-    }
-  }
-
-  const docCount = slugs.length;
-  const avgDocLength = docCount > 0 ? totalLength / docCount : 0;
-
-  function query(text: string, k: number): Slug[] {
-    if (k <= 0 || docCount === 0) return [];
-
-    const queryTerms = new Set(tokenize(text));
-    const scores = new Map<number, number>();
-
-    // O(query-terms x matching-docs): walk only the postings of query terms.
-    for (const term of queryTerms) {
-      const list = postings.get(term);
-      if (!list) continue;
-
-      const idf = Math.log(
-        1 + (docCount - list.length + 0.5) / (list.length + 0.5),
-      );
-
-      for (const { doc, tf } of list) {
-        const norm = tf * (k1 + 1);
-        const denom = tf + k1 * (1 - b + b * (docLengths[doc]! / avgDocLength));
-        scores.set(doc, (scores.get(doc) ?? 0) + idf * (norm / denom));
-      }
-    }
-
-    return [...scores.entries()]
-      .sort((a, c) => c[1] - a[1] || slugs[a[0]]!.localeCompare(slugs[c[0]]!))
-      .slice(0, k)
-      .map(([doc]) => slugs[doc]!);
-  }
-
-  return { query };
-}

package/src/memory/v3/orchestrate.ts

@@ -1,126 +0,0 @@
-/**
- * Memory v3 — orchestrator composing the four routing lanes into one turn.
- *
- * Each turn runs:
- *   1. L1 topical routing (`routeL1`) and the lexical BM25 needle
- *      (`NeedleIndex.query`) IN PARALLEL. Routing is the slow LLM arm; the
- *      needle is a synchronous in-memory lookup, so we wrap it in a resolved
- *      promise and let them settle together.
- *   2. Open set = unique union of routed leaves ∪ always-on core leaves ∪ the
- *      leaves that own each needle hit. Every lane only ever ADDS leaves — the
- *      union is recall-safe by construction.
- *   3. Bounded per-leaf L2 selection (`selectAcrossLeaves`) over the open set,
- *      then dedup by slug (a page assigned to multiple opened leaves comes back
- *      once per leaf) ORing the pinned flag so a page pinned anywhere stays
- *      pinned.
- *   4. Age the carry-forward working set to this turn (evict core slugs, stale
- *      non-pinned entries, then the cap) and snapshot it — the pages carried in
- *      from EARLIER turns.
- *   5. Final injection = unique union of this turn's selected slugs and that
- *      carried-forward set, so pages selected on earlier turns carry forward
- *      even when this turn does not re-select them.
- *   6. Record this turn's selections into the working set for LATER turns. This
- *      runs AFTER the snapshot so the cap is spent on genuinely carried pages,
- *      not on this turn's selections (which are injected directly) — otherwise a
- *      turn selecting more pages than the cap would evict the entire carry.
- */
-
-import type { NeedleIndex } from "./needle.js";
-import { routeL1 } from "./router.js";
-import type { SelectedPage } from "./selector.js";
-import { selectAcrossLeaves } from "./selector.js";
-import { coreSlugs, leavesOf } from "./tree.js";
-import type { LeafPath, LeafTree, Slug, TurnContext } from "./types.js";
-import { WorkingSet } from "./working-set.js";
-
-/** Default number of needle hits to fold into the open set when unspecified. */
-export const DEFAULT_NEEDLE_K = 10;
-
-export interface OrchestrateDeps {
-  tree: LeafTree;
-  core: Set<LeafPath>;
-  needle: NeedleIndex;
-  workingSet: WorkingSet;
-  pageSummary: (slug: Slug) => Promise<string>;
-  /** Number of BM25 needle hits to fold in. Defaults to {@link DEFAULT_NEEDLE_K}. */
-  needleK?: number;
-  /** Bounded fan-out for per-leaf L2 selection. */
-  l2Concurrency?: number;
-}
-
-export interface OrchestrateResult {
-  /** The unique open set: routed ∪ core ∪ needle-owning leaves. */
-  openedLeaves: LeafPath[];
-  /** This turn's L2 selections, deduped by slug (pinned flags ORed). */
-  currentSelections: SelectedPage[];
-  /** The carried-forward set: selections from EARLIER turns, aged to this turn
-   *  (snapshotted before this turn's selections are recorded). */
-  workingSetUnion: Set<Slug>;
-  /** Slugs to inject: this turn's selections ∪ the carried-forward working set. */
-  finalInjection: Slug[];
-}
-
-/** Stable-order de-duplication preserving first occurrence. */
-function unique<T>(items: Iterable<T>): T[] {
-  return [...new Set(items)];
-}
-
-export async function orchestrate(
-  turn: TurnContext,
-  deps: OrchestrateDeps,
-): Promise<OrchestrateResult> {
-  // Step 1: routing (LLM) and needle (sync BM25) run in parallel.
-  const needleK = deps.needleK ?? DEFAULT_NEEDLE_K;
-  const [routed, needled] = await Promise.all([
-    routeL1(turn, deps.tree),
-    Promise.resolve(deps.needle.query(turn.currentMessage, needleK)),
-  ]);
-
-  // Step 2: open set = routed ∪ core ∪ leaves owning each needle hit.
-  const openedLeaves = unique<LeafPath>([
-    ...routed,
-    ...deps.core,
-    ...needled.flatMap((slug) => leavesOf(deps.tree, slug)),
-  ]);
-
-  // Step 3: per-leaf L2 selection, then dedup by slug ORing pinned flags.
-  const selected = await selectAcrossLeaves(
-    openedLeaves,
-    turn,
-    deps.tree,
-    deps.pageSummary,
-    deps.l2Concurrency,
-  );
-  const bySlug = new Map<Slug, SelectedPage>();
-  for (const page of selected) {
-    const existing = bySlug.get(page.slug);
-    bySlug.set(page.slug, {
-      slug: page.slug,
-      pinned: (existing?.pinned ?? false) || page.pinned,
-    });
-  }
-  const currentSelections = [...bySlug.values()];
-
-  // Step 4: age the carry-forward set to this turn (drop core slugs, stale
-  // non-pinned entries, then the cap) and snapshot it. This is the set carried
-  // in from EARLIER turns; recording this turn happens afterward (step 6) so the
-  // cap is spent on genuinely carried pages, not on this turn's selections
-  // (which are injected directly anyway).
-  deps.workingSet.evict(turn.turnNumber, coreSlugs(deps.tree, deps.core));
-  const workingSetUnion = deps.workingSet.union();
-
-  // Step 5: final injection = this turn's selections ∪ the carried-forward set,
-  // so pages selected on earlier turns carry forward even when this turn does
-  // not re-select them.
-  const finalInjection = unique<Slug>([
-    ...currentSelections.map((s) => s.slug),
-    ...workingSetUnion,
-  ]);
-
-  // Step 6: record this turn's selections so they carry forward to LATER turns.
-  for (const sel of currentSelections) {
-    deps.workingSet.recordSelection(sel.slug, turn.turnNumber, sel.pinned);
-  }
-
-  return { openedLeaves, currentSelections, workingSetUnion, finalInjection };
-}

package/src/memory/v3/page-content.ts

@@ -1,34 +0,0 @@
-import { getWorkspaceDir } from "../../util/platform.js";
-import { readPage, renderPageContent } from "../v2/page-store.js";
-import { renderCapabilityContent } from "./capabilities.js";
-import type { Slug } from "./types.js";
-
-/**
- * Render a selected page's full content for the v3 `<memory>` block. Mirrors
- * the v2 dynamic-memory layout (`# memory/concepts/<slug>.md\n<frontmatter+body>`)
- * so the working-set block reads like v2's. A missing page (or any read
- * failure) degrades to "" — `renderMemoryBlock` still emits a line for the
- * slug, and a blank section is preferable to throwing into the turn.
- *
- * Synthetic capability slugs (skills, `assistant` CLI commands) have no on-disk
- * page; they resolve through {@link renderCapabilityContent} instead of
- * `readPage`. A non-null result (including "") means the slug was a capability
- * slug and was handled here.
- *
- * Shared by the live injector (`shadow-plugin.ts`) and the inspector
- * selection-log store (`selection-log-store.ts`) so the inspector's rendered
- * block is byte-identical to what live injection produces.
- */
-export async function renderV3PageContent(slug: Slug): Promise<string> {
-  const capability = renderCapabilityContent(slug);
-  if (capability !== null) return capability;
-  try {
-    const page = await readPage(getWorkspaceDir(), slug);
-    if (!page) return "";
-    const content = renderPageContent(page).trim();
-    if (content.length === 0) return "";
-    return `# memory/concepts/${slug}.md\n${content}`;
-  } catch {
-    return "";
-  }
-}

package/src/memory/v3/provider-blocks.ts

@@ -1,26 +0,0 @@
-import type { ContentBlock } from "../../providers/types.js";
-
-/**
- * Text content block carrying a `cache_control` breakpoint with a 1-hour TTL.
- * Shared by the v3 router (the static leaf-tree block) and selector (each
- * leaf's static `<pages>` block): these prefixes are stable across turns — the
- * leaf tree is byte-identical every turn, and a leaf's pages block changes only
- * when its pages/summaries do — while v3 turns are frequently more than the
- * default 5-minute cache window apart. A 1h TTL keeps the prefix warm across
- * those gaps so it is read from cache rather than re-created every turn; the
- * volatile current-message block is rendered after this one and left un-cached.
- * Haiku does not support the extended-cache-ttl beta, so the Anthropic provider
- * strips this `ttl` for Haiku models.
- *
- * Our internal `TextContent` type omits `cache_control` (only the Anthropic
- * provider transforms it onto the wire), so we reach through a `Record` cast to
- * keep the core types provider-agnostic.
- */
-export function cachedTextBlock(text: string): ContentBlock {
-  const block: ContentBlock = { type: "text", text };
-  (block as unknown as Record<string, unknown>).cache_control = {
-    type: "ephemeral",
-    ttl: "1h",
-  };
-  return block;
-}