@vellumai/assistant 0.8.4 → 0.8.6

package/src/memory/v2/harness/replay-input.ts

@@ -0,0 +1,240 @@
+/**
+ * Input reconstruction — rebuild a retriever's per-turn inputs from telemetry.
+ *
+ * The activation log stores only outputs, so replaying a historical turn means
+ * reconstructing the inputs:
+ *  - `recentTurnPairs`: the (assistant, user) pairs ending at the turn's user
+ *    message, windowed by `historical_pairs` and extracted exactly as
+ *    production does (mirrors `extractRecentTurnPairs` in
+ *    `conversation-graph-memory.ts`).
+ *  - `nowText`: read from current workspace files (`loadNowText`). NOT stored
+ *    in the log, so it may differ from what the live turn saw —
+ *    always-approximate; see `ReconstructionMeta.nowReconstructedFromCurrent`.
+ *  - `priorEverInjected`: the union of retained slugs from earlier
+ *    `mode='router'` logs in the same conversation (turn < target). Retained
+ *    statuses mirror production's `everInjected` (injected / in_context, plus
+ *    page_missing / corrupt — see `PRIOR_STATUSES`).
+ *
+ * The anchor is the turn's assistant reply; the messages the router saw are
+ * those strictly before it, so we fetch a bounded recent window up to the
+ * anchor's timestamp and cut at the anchor row.
+ */
+
+import { and, asc, desc, eq, lt, lte } from "drizzle-orm";
+
+import type { AssistantConfig } from "../../../config/types.js";
+import type { ContentBlock } from "../../../providers/types.js";
+import type { DrizzleDb } from "../../db-connection.js";
+import type { MemoryV2ConceptRowRecord } from "../../memory-v2-activation-log-store.js";
+import { memoryV2ActivationLogs, messages } from "../../schema.js";
+import { loadNowText } from "../now-text.js";
+import type { RouterTurnPair } from "../router.js";
+import type { EverInjectedEntry } from "../types.js";
+import type { OracleTurn } from "./oracle.js";
+import type { RetrievalInput } from "./retriever.js";
+
+export interface ReconstructionMeta {
+  /** `historical_pairs` window requested. */
+  windowPairs: number;
+  /** Pairs actually reconstructed (may be < window near conversation start). */
+  pairsReconstructed: number;
+  /** `priorEverInjected` entries reconstructed from earlier router logs. */
+  priorEverInjectedCount: number;
+  /**
+   * NOW text is read from current workspace files — it is not stored in the
+   * log and may differ from what the live turn saw. Always true; a recall gap
+   * is partly attributable to this unmeasured drift.
+   */
+  nowReconstructedFromCurrent: true;
+}
+
+export interface ReconstructedInput {
+  input: RetrievalInput;
+  meta: ReconstructionMeta;
+}
+
+/** Minimal message shape for pair extraction. */
+interface PlainMessage {
+  role: string;
+  content: ContentBlock[];
+}
+
+/**
+ * Mirror of production `extractRecentTurnPairs`: walk messages newest-first,
+ * pair each user message with the preceding assistant reply, keep the last `k`
+ * pairs (oldest first). A leading user message with no prior assistant reply is
+ * emitted with an empty `assistantMessage`.
+ */
+function extractRecentTurnPairs(
+  msgs: readonly PlainMessage[],
+  k: number,
+): RouterTurnPair[] {
+  const messageText = (msg: PlainMessage): string =>
+    msg.content
+      .filter(
+        (b): b is Extract<ContentBlock, { type: "text" }> => b.type === "text",
+      )
+      .map((b) => b.text)
+      .join(" ");
+
+  const pairs: RouterTurnPair[] = [];
+  let pendingUser: string | null = null;
+  for (let i = msgs.length - 1; i >= 0 && pairs.length < k; i--) {
+    const msg = msgs[i]!;
+    if (msg.role === "user" && pendingUser === null) {
+      pendingUser = messageText(msg);
+    } else if (msg.role === "assistant" && pendingUser !== null) {
+      pairs.unshift({
+        assistantMessage: messageText(msg),
+        userMessage: pendingUser,
+      });
+      pendingUser = null;
+    }
+  }
+  if (pendingUser !== null && pairs.length < k) {
+    pairs.unshift({ assistantMessage: "", userMessage: pendingUser });
+  }
+  if (pairs.length === 0) {
+    pairs.push({ assistantMessage: "", userMessage: "" });
+  }
+  return pairs;
+}
+
+function parseContent(raw: string): ContentBlock[] {
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? (parsed as ContentBlock[]) : [];
+  } catch {
+    return [];
+  }
+}
+
+export async function reconstructInput(
+  db: DrizzleDb,
+  turn: OracleTurn,
+  config: AssistantConfig,
+  workspaceDir: string,
+): Promise<ReconstructedInput | null> {
+  const windowPairs = config.memory.v2.router.historical_pairs;
+
+  // Fetch a bounded recent window up to the anchor's timestamp (newest first),
+  // then cut everything at/after the anchor reply. We only need the last
+  // `windowPairs` (assistant,user) pairs, so a small generous bound suffices
+  // even for very long conversations.
+  const fetchWindow = Math.max(20, windowPairs * 12);
+  const recent = db
+    .select({
+      id: messages.id,
+      role: messages.role,
+      content: messages.content,
+    })
+    .from(messages)
+    .where(
+      and(
+        eq(messages.conversationId, turn.conversationId),
+        lte(messages.createdAt, turn.anchorCreatedAt),
+      ),
+    )
+    .orderBy(desc(messages.createdAt), desc(messages.id))
+    .limit(fetchWindow)
+    .all();
+
+  const anchorPos = recent.findIndex((m) => m.id === turn.anchorMessageId);
+  if (anchorPos < 0) return null;
+  const beforeAnchor = recent.slice(anchorPos + 1);
+  if (beforeAnchor.length === 0) return null;
+
+  const plain: PlainMessage[] = beforeAnchor
+    .slice()
+    .reverse()
+    .map((m) => ({ role: m.role, content: parseContent(m.content) }));
+
+  const recentTurnPairs = extractRecentTurnPairs(plain, windowPairs);
+  const priorEverInjected = reconstructPriorEverInjected(
+    db,
+    turn.conversationId,
+    turn.turn,
+  );
+  const nowText = await loadNowText(workspaceDir);
+
+  return {
+    input: {
+      workspaceDir,
+      recentTurnPairs,
+      nowText,
+      priorEverInjected,
+      config,
+    },
+    meta: {
+      windowPairs,
+      pairsReconstructed: recentTurnPairs.length,
+      priorEverInjectedCount: priorEverInjected.length,
+      nowReconstructedFromCurrent: true,
+    },
+  };
+}
+
+// Production's `everInjected` retains a slug once it is rendered, EXCEPT for
+// missing synthetic slugs (skills/CLI commands whose capability cache is empty
+// — see `missingSyntheticSlugs` in `injection.ts`). Concept pages that turn out
+// `page_missing` or `corrupt` at render time are still retained so they aren't
+// re-attempted every turn (see the `page_missing ... DOES land in everInjected`
+// case in `injection.test.ts`). The replay must mirror that retention or it
+// builds a narrower prior-state than live routing, skewing comparisons. Missing
+// synthetic slugs never enter the missing/corrupt buckets — they log as
+// `injected` — so widening here introduces no new synthetic-slug discrepancy.
+const PRIOR_STATUSES = new Set<string>([
+  "injected",
+  "in_context",
+  "page_missing",
+  "corrupt",
+]);
+
+/**
+ * Union of slugs injected on earlier `mode='router'` turns in this conversation
+ * (turn < `currentTurn`), each tagged with the earliest turn it appeared on —
+ * the harness analogue of the running `everInjected` list production maintains.
+ */
+function reconstructPriorEverInjected(
+  db: DrizzleDb,
+  conversationId: string,
+  currentTurn: number,
+): EverInjectedEntry[] {
+  const rows = db
+    .select({
+      turn: memoryV2ActivationLogs.turn,
+      conceptsJson: memoryV2ActivationLogs.conceptsJson,
+    })
+    .from(memoryV2ActivationLogs)
+    .where(
+      and(
+        eq(memoryV2ActivationLogs.conversationId, conversationId),
+        eq(memoryV2ActivationLogs.mode, "router"),
+        lt(memoryV2ActivationLogs.turn, currentTurn),
+      ),
+    )
+    .orderBy(asc(memoryV2ActivationLogs.turn))
+    .all();
+
+  const firstTurnBySlug = new Map<string, number>();
+  for (const row of rows) {
+    let concepts: MemoryV2ConceptRowRecord[];
+    try {
+      concepts = JSON.parse(row.conceptsJson) as MemoryV2ConceptRowRecord[];
+    } catch {
+      continue;
+    }
+    for (const concept of concepts) {
+      if (!PRIOR_STATUSES.has(concept.status)) continue;
+      if (!firstTurnBySlug.has(concept.slug)) {
+        firstTurnBySlug.set(concept.slug, row.turn);
+      }
+    }
+  }
+
+  const entries: EverInjectedEntry[] = [];
+  firstTurnBySlug.forEach((turn, slug) => {
+    entries.push({ slug, turn });
+  });
+  return entries;
+}

package/src/memory/v2/harness/retriever.ts

@@ -0,0 +1,74 @@
+/**
+ * The retriever seam for the memory comparison harness.
+ *
+ * A `Retriever` maps one turn's reconstructed context to a set of selected
+ * concept-page slugs. Multiple strategies (the production router, an
+ * alternative retrieval loop) implement this single interface, so the harness
+ * can run them over the same turns and diff their selections against the oracle
+ * (see `oracle.ts`). Offline only — nothing here runs in the live injection
+ * path.
+ */
+
+import type { AssistantConfig } from "../../../config/types.js";
+import type { RouterTurnPair } from "../router.js";
+import type { EverInjectedEntry } from "../types.js";
+import type { DescentTrace } from "./trace.js";
+
+/**
+ * Per-turn context a retriever needs, mirroring the live router's inputs
+ * (`RunRouterParams`). Reconstructed from historical telemetry by
+ * `reconstructInput` (see `replay-input.ts`).
+ */
+export interface RetrievalInput {
+  workspaceDir: string;
+  /**
+   * Recent (assistant, user) pairs, oldest first. The last entry's
+   * `userMessage` is the just-arrived turn being routed.
+   */
+  recentTurnPairs: readonly RouterTurnPair[];
+  /** NOW context (essentials/threads/recent), verbatim. */
+  nowText: string;
+  /** Slugs already injected on prior turns. */
+  priorEverInjected: readonly EverInjectedEntry[];
+  config: AssistantConfig;
+  signal?: AbortSignal;
+}
+
+/** Optional cost accounting for a single retrieval. */
+export interface RetrievalCost {
+  inputTokens?: number;
+  outputTokens?: number;
+  usd?: number;
+  ms?: number;
+}
+
+/** What a retriever returns for one turn. */
+export interface RetrievalOutput {
+  /** Selected page slugs, in the retriever's own ranked order. */
+  selectedSlugs: string[];
+  /**
+   * Per-slug provenance / lane label, retriever-defined — router tiers
+   * (`tier1`, `tier3:0`, …) for the current router, or loop lanes (`sparse`,
+   * `dense`, `tree`, `edge`) for the future loop. Drives per-lane attribution
+   * in `metrics.ts`.
+   */
+  sourceBySlug: ReadonlyMap<string, string>;
+  /**
+   * Loop-only descent trace. Tier-based retrievers (the current router) have
+   * no tree walk and leave this `undefined`; renderers show "(no descent
+   * trace)".
+   */
+  trace?: DescentTrace;
+  cost?: RetrievalCost;
+  /** Non-null when the retriever could not produce a usable selection. */
+  failureReason?: string | null;
+}
+
+/**
+ * A named retrieval strategy. Implementations must not mutate production state
+ * — the harness runs them offline over historical turns.
+ */
+export interface Retriever {
+  readonly name: string;
+  retrieve(input: RetrievalInput): Promise<RetrievalOutput>;
+}

package/src/memory/v2/harness/router-retriever.ts

@@ -0,0 +1,43 @@
+/**
+ * Router retriever — the current production router (`runRouter`) adapted to the
+ * harness `Retriever` interface.
+ *
+ * The union cap is left ON (no `disableUnionCap`) so the selection matches what
+ * production would actually inject — the self-test grades the router against
+ * its own injected ground truth.
+ */
+
+import type { DrizzleDb } from "../../db-connection.js";
+import { runRouter } from "../router.js";
+import type {
+  RetrievalInput,
+  RetrievalOutput,
+  Retriever,
+} from "./retriever.js";
+
+/**
+ * @param database optional handle for tier-2 EMA scoring, forwarded to
+ * `runRouter`. Omit to exercise only the tier-1 / tier-3 paths (as the router's
+ * own tests do).
+ */
+export function createRouterRetriever(database?: DrizzleDb): Retriever {
+  return {
+    name: "router",
+    async retrieve(input: RetrievalInput): Promise<RetrievalOutput> {
+      const result = await runRouter({
+        workspaceDir: input.workspaceDir,
+        recentTurnPairs: input.recentTurnPairs,
+        nowText: input.nowText,
+        priorEverInjected: input.priorEverInjected,
+        config: input.config,
+        ...(input.signal ? { signal: input.signal } : {}),
+        ...(database ? { database } : {}),
+      });
+      return {
+        selectedSlugs: result.selectedSlugs,
+        sourceBySlug: result.sourceBySlug,
+        failureReason: result.failureReason,
+      };
+    },
+  };
+}

package/src/memory/v2/harness/runner.ts

@@ -0,0 +1,112 @@
+/**
+ * Comparison runner — execute N retrievers over a set of oracle turns and score
+ * each against ground truth.
+ *
+ * The runner is DB/workspace-agnostic: input reconstruction is injected as a
+ * function, so it can be unit-tested with stubs and the route/CLI can wire in
+ * the real `reconstructInput` (which needs a DB + workspace).
+ */
+
+import {
+  aggregate,
+  type AggregateEval,
+  evalTurn,
+  type TurnEval,
+} from "./metrics.js";
+import type { OracleTurn } from "./oracle.js";
+import type { ReconstructedInput } from "./replay-input.js";
+import type { Retriever } from "./retriever.js";
+
+export interface ComparisonTurnResult {
+  conversationId: string;
+  turn: number;
+  /** Per-retriever evaluation for this turn, keyed by retriever name. */
+  byRetriever: Record<string, TurnEval>;
+}
+
+export interface RetrieverReport {
+  name: string;
+  aggregate: AggregateEval;
+}
+
+export interface ComparisonReport {
+  ks: number[];
+  /** Oracle turns handed to the runner. */
+  turnsConsidered: number;
+  /** Turns actually scored (reconstruction succeeded). */
+  turnsScored: number;
+  /** Turns skipped because input reconstruction returned null. */
+  turnsSkipped: number;
+  perTurn: ComparisonTurnResult[];
+  retrievers: RetrieverReport[];
+}
+
+export interface RunComparisonParams {
+  retrievers: readonly Retriever[];
+  oracleTurns: readonly OracleTurn[];
+  /** Reconstruct a turn's retriever input; return null to skip the turn. */
+  reconstruct: (turn: OracleTurn) => Promise<ReconstructedInput | null>;
+  ks: readonly number[];
+  signal?: AbortSignal;
+}
+
+export async function runComparison(
+  params: RunComparisonParams,
+): Promise<ComparisonReport> {
+  const { retrievers, oracleTurns, reconstruct, ks, signal } = params;
+
+  const perTurn: ComparisonTurnResult[] = [];
+  const perRetrieverEvals = new Map<string, TurnEval[]>();
+  for (const retriever of retrievers) {
+    perRetrieverEvals.set(retriever.name, []);
+  }
+
+  let turnsScored = 0;
+  let turnsSkipped = 0;
+
+  for (const turn of oracleTurns) {
+    if (signal?.aborted) break;
+
+    const reconstructed = await reconstruct(turn);
+    if (!reconstructed) {
+      turnsSkipped++;
+      continue;
+    }
+    turnsScored++;
+
+    // Thread the abort signal into the reconstructed input so retrievers that
+    // wrap LLM calls (e.g. the router retriever forwarding to `runRouter`) abort
+    // the in-flight per-turn call on caller disconnect — the loop gating below
+    // only stops scheduling new work, it can't cancel the current retrieval.
+    if (signal) reconstructed.input.signal = signal;
+
+    const byRetriever: Record<string, TurnEval> = {};
+    for (const retriever of retrievers) {
+      if (signal?.aborted) break;
+      const output = await retriever.retrieve(reconstructed.input);
+      const turnEval = evalTurn(output, turn.groundTruthSlugs, ks);
+      byRetriever[retriever.name] = turnEval;
+      perRetrieverEvals.get(retriever.name)?.push(turnEval);
+    }
+
+    perTurn.push({
+      conversationId: turn.conversationId,
+      turn: turn.turn,
+      byRetriever,
+    });
+  }
+
+  const retrieverReports: RetrieverReport[] = retrievers.map((retriever) => ({
+    name: retriever.name,
+    aggregate: aggregate(perRetrieverEvals.get(retriever.name) ?? [], ks),
+  }));
+
+  return {
+    ks: [...ks],
+    turnsConsidered: oracleTurns.length,
+    turnsScored,
+    turnsSkipped,
+    perTurn,
+    retrievers: retrieverReports,
+  };
+}

package/src/memory/v2/harness/trace.ts

@@ -0,0 +1,64 @@
+/**
+ * Descent-trace schema for a tree-walking retriever.
+ *
+ * Defined ahead of its producer: the comparison harness renders this and a
+ * tree-walking retriever emits it; a tier-based retriever (no tree walk) leaves
+ * `RetrievalOutput.trace` undefined. Per level it records which branches were
+ * considered, descended, and skipped plus the model's reasoning, so a wrong
+ * high-level skip is observable rather than silent.
+ */
+
+import type { RetrievalCost } from "./retriever.js";
+
+/** A scout lane's contribution on one pass. */
+export interface ScoutResult {
+  lane: "hot" | "sparse" | "dense";
+  slugs: string[];
+  /** Optional per-slug score (BM25 / cosine / EMA) for inspection. */
+  scoreBySlug?: Record<string, number>;
+}
+
+/** One level of the tree walk: what was considered, descended, and skipped. */
+export interface TreeLevel {
+  /** Node whose index page was read ("" for root, else a branch path). */
+  node: string;
+  considered: string[];
+  descended: string[];
+  skipped: string[];
+  /** The model's stated reason for the descend/skip split at this node. */
+  reasoning: string;
+  cost?: RetrievalCost;
+}
+
+/** A 1–2 hop walk along the curated `edges:` graph from a seed page. */
+export interface EdgeExpansion {
+  from: string;
+  pulled: string[];
+}
+
+/** The gate's decision at the end of a pass. */
+export interface GateDecision {
+  decision: "ready" | "more";
+  /** When "more", the generated follow-up queries seeding the next pass. */
+  questions?: string[];
+  /**
+   * The gate's one-line rationale for this verdict, when it supplied one.
+   * Surfaced in the descent trace and the live-shadow telemetry so a run can be
+   * analyzed after the fact ("why did the gate keep this set?").
+   */
+  reasoning?: string;
+}
+
+/** Everything that happened on one pass of the loop. */
+export interface DescentPass {
+  passNumber: number;
+  scouts?: ScoutResult[];
+  treeLevels?: TreeLevel[];
+  edgeExpansions?: EdgeExpansion[];
+  gate?: GateDecision;
+}
+
+/** A full loop execution, pass by pass. */
+export interface DescentTrace {
+  passes: DescentPass[];
+}

package/src/memory/v2/injection.ts

@@ -45,7 +45,7 @@ import {
 import { getEdgeIndex } from "./edge-index.js";
 import { recordInjectionEvents } from "./injection-events.js";
 import { readPage, renderPageContent } from "./page-store.js";
-import { runRouter } from "./router.js";
+import { type RouterTurnPair, runRouter } from "./router.js";
 import { getSkillCapability, isSkillSlug } from "./skill-store.js";
 import type { ActivationState, EverInjectedEntry } from "./types.js";
 
@@ -81,10 +81,13 @@ export interface InjectMemoryV2BlockParams {
   conversationId: string;
   /** Caller-tracked turn number, persisted with each new everInjected entry. */
   currentTurn: number;
-  /** Latest user message text (the turn that triggered this call). */
-  userMessage: string;
-  /** Prior assistant message text (empty string at conversation start). */
-  assistantMessage: string;
+  /**
+   * Recent assistant/user turn pairs, oldest first. Must contain at least
+   * one entry whose `userMessage` is the just-arrived turn that triggered
+   * this call. The number of pairs the production caller passes is
+   * controlled by `memory.v2.router.historical_pairs`.
+   */
+  recentTurnPairs: readonly RouterTurnPair[];
   /** NOW context (autoloaded essentials/threads/recent or NOW.md). */
   nowText: string;
   /** Resolved messageId to persist on the activation_state row. */
@@ -140,14 +143,21 @@ export async function injectMemoryV2Block(
     database,
     conversationId,
     currentTurn,
-    userMessage,
-    assistantMessage,
+    recentTurnPairs,
     nowText,
     messageId,
     config,
     signal,
   } = params;
 
+  // The spreading-activation fallback (only used when the router is off)
+  // still needs the most recent (assistant, user) pair for semantic
+  // scoring. Pulling these from the last pair preserves bit-identical
+  // K=1 behavior — the router-off path never benefits from extra pairs.
+  const lastPair = recentTurnPairs[recentTurnPairs.length - 1];
+  const userMessage = lastPair.userMessage;
+  const assistantMessage = lastPair.assistantMessage;
+
   const workspaceDir = getWorkspaceDir();
   const mode: InjectMemoryV2Mode = params.mode ?? "per-turn";
 
@@ -174,8 +184,7 @@ export async function injectMemoryV2Block(
       database,
       conversationId,
       currentTurn,
-      userMessage,
-      assistantMessage,
+      recentTurnPairs,
       nowText,
       messageId,
       config,
@@ -521,8 +530,7 @@ async function injectViaRouter(args: {
   database: DrizzleDb;
   conversationId: string;
   currentTurn: number;
-  userMessage: string;
-  assistantMessage: string;
+  recentTurnPairs: readonly RouterTurnPair[];
   nowText: string;
   messageId: string;
   config: AssistantConfig;
@@ -534,8 +542,7 @@ async function injectViaRouter(args: {
     database,
     conversationId,
     currentTurn,
-    userMessage,
-    assistantMessage,
+    recentTurnPairs,
     nowText,
     messageId,
     config,
@@ -548,8 +555,7 @@ async function injectViaRouter(args: {
 
   const routerResult = await runRouter({
     workspaceDir,
-    userMessage,
-    assistantMessage,
+    recentTurnPairs,
     nowText,
     priorEverInjected,
     config,

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

@@ -56,8 +56,11 @@ const PAGE_INDEX_PLACEHOLDER = "{{PAGE_INDEX}}";
  * Recent message context and `<now>` / `<already_injected_ids>` blocks are
  * appended at the call site so we don't inadvertently expand `{{` inside
  * dynamic content.
+ *
+ * Exported so the simulator route can return the bundled template verbatim
+ * for the playground's "Load default" affordance.
  */
-const ROUTER_PROMPT = `You are a background helper for ${ASSISTANT_NAME_PLACEHOLDER}. Your job is to route memory pages for the next assistant turn between ${ASSISTANT_NAME_PLACEHOLDER} and ${USER_NAME_PLACEHOLDER}.
+export const ROUTER_PROMPT = `You are a background helper for ${ASSISTANT_NAME_PLACEHOLDER}. Your job is to route memory pages for the next assistant turn between ${ASSISTANT_NAME_PLACEHOLDER} and ${USER_NAME_PLACEHOLDER}.
 
 You will be shown the recent conversation, a \`<now>\` marker for the current time, an \`<already_injected_ids>\` block listing pages picked on the previous turn, and a \`# Concept Page Index\` listing every routable page on this workspace.
 
@@ -112,7 +115,29 @@ export function resolveRouterPrompt(
   overridePath: string | null,
   workspaceDir: string,
   opts: RenderRouterPromptOpts,
+  inlineOverride?: string | null,
 ): string {
+  // Inline override (e.g. simulator playground) takes precedence over the
+  // configured file path and the bundled prompt. Same placeholder
+  // substitution + size guard as the file-path branch; empty/whitespace
+  // bodies fall through to file/bundled resolution so a "cleared" textarea
+  // is treated as no override.
+  if (inlineOverride !== undefined && inlineOverride !== null) {
+    if (inlineOverride.length > MAX_PROMPT_BYTES) {
+      log.warn(
+        {
+          size: inlineOverride.length,
+          limit: MAX_PROMPT_BYTES,
+          reason: "oversized_inline_override",
+          fallback: "path_or_bundled",
+        },
+        "inline router prompt override exceeds size limit; falling back",
+      );
+    } else if (inlineOverride.trim().length > 0) {
+      return substitutePlaceholders(inlineOverride, opts);
+    }
+  }
+
   if (overridePath === null) return renderRouterPrompt(opts);
 
   const resolvedPath = resolveOverridePath(overridePath, workspaceDir);