@vellumai/assistant 0.11.0 → 0.11.1-staging.2

package/src/plugins/defaults/memory/v3/render-injection.ts

@@ -20,7 +20,9 @@ export const V3_CARDS_INJECTION_HEADER =
  * `memoryInjectedBlock`.
  */
 export function renderCardsBlockInner(cards: string[]): string {
-  if (cards.length === 0) return "";
+  if (cards.length === 0) {
+    return "";
+  }
   return [V3_CARDS_INJECTION_HEADER, ...cards].join("\n\n");
 }
 
@@ -82,7 +84,9 @@ export async function renderMemoryBlock(
   sectionBySlug: Map<Slug, Section>,
   pageContent: (slug: Slug, section: Section | undefined) => Promise<string>,
 ): Promise<string> {
-  if (slugs.length === 0) return "";
+  if (slugs.length === 0) {
+    return "";
+  }
 
   const contents = await Promise.all(
     slugs.map((slug) => pageContent(slug, sectionBySlug.get(slug))),

package/src/plugins/defaults/memory/v3/section-dense-store.ts

@@ -26,7 +26,6 @@ import { v5 as uuidv5 } from "uuid";
 
 import type { AssistantConfig } from "../../../../config/types.js";
 import { deleteMemoryCheckpoint } from "../../../../persistence/checkpoints.js";
-import { getDb } from "../../../../persistence/db-connection.js";
 import {
   geminiCacheExtras,
   getMemoryBackendStatus,
@@ -38,6 +37,7 @@ import {
 import { embeddingInputContentHash } from "../../../../persistence/embeddings/embedding-types.js";
 import { embedWithBackend, resolveQdrantUrl } from "../embeddings.js";
 import { getLogger } from "../logging.js";
+import { memoryDbOrNull } from "../memory-db.js";
 import type { Section } from "./types.js";
 
 const log = getLogger("memory-v3-section-dense-store");
@@ -77,7 +77,9 @@ let _collectionReady = false;
  * `dense.ts`) so they reuse one client instance and one reset hook.
  */
 export function getSectionDenseClient(): QdrantRestClient {
-  if (_client) return _client;
+  if (_client) {
+    return _client;
+  }
   _client = new QdrantRestClient({
     url: resolveQdrantUrl(),
     checkCompatibility: false,
@@ -103,7 +105,9 @@ function pointIdForSection(article: string, ordinal: number): string {
 export async function ensureSectionCollection(
   config: AssistantConfig,
 ): Promise<void> {
-  if (_collectionReady) return;
+  if (_collectionReady) {
+    return;
+  }
 
   const client = getSectionDenseClient();
   const vectorSize = config.memory.qdrant.vectorSize;
@@ -176,7 +180,9 @@ export async function ensureSectionCollection(
         err instanceof Error && "status" in err
           ? (err as { status: number }).status
           : undefined;
-      if (status !== 409) throw err;
+      if (status !== 409) {
+        throw err;
+      }
     }
 
     // A freshly (re)created collection is empty, so the section dense store
@@ -246,7 +252,9 @@ function sectionCacheId(article: string, ordinal: number): string {
  */
 function sectionContentHash(text: string, extras: string[]): string {
   const base = embeddingInputContentHash({ type: "text", text });
-  if (extras.length === 0) return base;
+  if (extras.length === 0) {
+    return base;
+  }
   return createHash("sha256")
     .update(`${base}\0${extras.join("\0")}`)
     .digest("hex");
@@ -269,7 +277,9 @@ export async function upsertSections(
   config: AssistantConfig,
   sections: Section[],
 ): Promise<void> {
-  if (sections.length === 0) return;
+  if (sections.length === 0) {
+    return;
+  }
 
   await ensureSectionCollection(config);
 
@@ -277,7 +287,9 @@ export async function upsertSections(
 
   const points = sections.flatMap((section, i) => {
     const vector = vectors[i];
-    if (!vector) return [];
+    if (!vector) {
+      return [];
+    }
     return [
       {
         id: pointIdForSection(section.article, section.ordinal),
@@ -291,7 +303,9 @@ export async function upsertSections(
     ];
   });
 
-  if (points.length === 0) return;
+  if (points.length === 0) {
+    return;
+  }
 
   await getSectionDenseClient().upsert(SECTION_COLLECTION, {
     wait: true,
@@ -323,7 +337,7 @@ async function embedSectionsCached(
   // no provider resolves (backend down/disabled) skip the cache and let the
   // batched embed below surface the failure exactly as the uncached path did.
   const status = await getMemoryBackendStatus(config);
-  const db = getDb();
+  const mem = memoryDbOrNull("embedSectionsCached");
 
   // Only Gemini's options change the vector for identical text, so fold the
   // extras into the cache identity only when Gemini is the resolved provider;
@@ -333,10 +347,10 @@ async function embedSectionsCached(
 
   const result: Array<number[] | undefined> = new Array(sections.length);
   const missIndices: number[] = [];
-  if (status.provider && status.model) {
+  if (mem && status.provider && status.model) {
     for (let i = 0; i < sections.length; i++) {
       const section = sections[i]!;
-      const cached = readEmbeddingCache(db, {
+      const cached = readEmbeddingCache(mem, {
         targetType: V3_SECTION_TARGET_TYPE,
         targetId: sectionCacheId(section.article, section.ordinal),
         provider: status.provider,
@@ -350,10 +364,14 @@ async function embedSectionsCached(
       }
     }
   } else {
-    for (let i = 0; i < sections.length; i++) missIndices.push(i);
+    for (let i = 0; i < sections.length; i++) {
+      missIndices.push(i);
+    }
   }
 
-  if (missIndices.length === 0) return result;
+  if (missIndices.length === 0) {
+    return result;
+  }
 
   // Embed the misses in one batched call (the dominant cost).
   let embedded = await embedWithBackend(
@@ -386,18 +404,22 @@ async function embedSectionsCached(
   for (let j = 0; j < effectiveIndices.length; j++) {
     const i = effectiveIndices[j]!;
     const vector = embedded.vectors[j];
-    if (!vector) continue;
+    if (!vector) {
+      continue;
+    }
     result[i] = vector;
     const section = sections[i]!;
-    writeEmbeddingCache(db, {
-      targetType: V3_SECTION_TARGET_TYPE,
-      targetId: sectionCacheId(section.article, section.ordinal),
-      dense: vector,
-      contentHash: hashes[i]!,
-      provider: writeProvider,
-      model: writeModel,
-      now,
-    });
+    if (mem) {
+      writeEmbeddingCache(mem, {
+        targetType: V3_SECTION_TARGET_TYPE,
+        targetId: sectionCacheId(section.article, section.ordinal),
+        dense: vector,
+        contentHash: hashes[i]!,
+        provider: writeProvider,
+        model: writeModel,
+        now,
+      });
+    }
   }
 
   return result;
@@ -451,10 +473,14 @@ export async function listSectionArticles(
     });
     for (const point of result.points) {
       const article = (point.payload as { article?: unknown } | null)?.article;
-      if (typeof article === "string") articles.add(article);
+      if (typeof article === "string") {
+        articles.add(article);
+      }
     }
     const next = result.next_page_offset;
-    if (next == null) break;
+    if (next == null) {
+      break;
+    }
     offset = typeof next === "string" ? next : (next as number);
   }
 

package/src/plugins/defaults/memory/v3/section-needle.ts

@@ -82,7 +82,9 @@ function tokenize(text: string): string[] {
 /** Split a section's text into its head line and the remaining body. */
 function splitHeadBody(text: string): { head: string; body: string } {
   const newline = text.indexOf("\n");
-  if (newline === -1) return { head: text, body: "" };
+  if (newline === -1) {
+    return { head: text, body: "" };
+  }
   return { head: text.slice(0, newline), body: text.slice(newline + 1) };
 }
 
@@ -145,11 +147,15 @@ export function buildSectionNeedle(index: SectionIndex): SectionNeedle {
   /** BM25F score per section for the given query terms. */
   function scoreSections(queryTerms: Set<string>): Map<number, number> {
     const scores = new Map<number, number>();
-    if (docCount === 0) return scores;
+    if (docCount === 0) {
+      return scores;
+    }
 
     for (const term of queryTerms) {
       const list = postings.get(term);
-      if (!list) continue;
+      if (!list) {
+        continue;
+      }
 
       const termIdf = idfFromDf(list.length);
 
@@ -171,18 +177,24 @@ export function buildSectionNeedle(index: SectionIndex): SectionNeedle {
     scores: Map<number, number>,
   ): number {
     const byScore = (scores.get(c) ?? 0) - (scores.get(a) ?? 0);
-    if (byScore !== 0) return byScore;
+    if (byScore !== 0) {
+      return byScore;
+    }
     const sa = sections[a]!;
     const sc = sections[c]!;
     return sa.article.localeCompare(sc.article) || sa.ordinal - sc.ordinal;
   }
 
   function queryScored(text: string, k: number): SectionNeedleScoredHit[] {
-    if (k <= 0 || docCount === 0) return [];
+    if (k <= 0 || docCount === 0) {
+      return [];
+    }
 
     const queryTerms = new Set(tokenize(text));
     const scores = scoreSections(queryTerms);
-    if (scores.size === 0) return [];
+    if (scores.size === 0) {
+      return [];
+    }
 
     const ranked = [...scores.keys()].sort((a, c) => rankSection(a, c, scores));
 
@@ -192,10 +204,14 @@ export function buildSectionNeedle(index: SectionIndex): SectionNeedle {
     const result: SectionNeedleScoredHit[] = [];
     for (const doc of ranked) {
       const article = sections[doc]!.article;
-      if (seen.has(article)) continue;
+      if (seen.has(article)) {
+        continue;
+      }
       seen.add(article);
       result.push({ article, section: doc, score: scores.get(doc) ?? 0 });
-      if (result.length >= k) break;
+      if (result.length >= k) {
+        break;
+      }
     }
     return result;
   }
@@ -212,7 +228,9 @@ export function buildSectionNeedle(index: SectionIndex): SectionNeedle {
 
   function bestSection(article: Slug, queryText: string): number {
     const docs = index.byArticle.get(article);
-    if (!docs || docs.length === 0) return -1;
+    if (!docs || docs.length === 0) {
+      return -1;
+    }
 
     const queryTerms = new Set(tokenize(queryText));
     const scores = scoreSections(queryTerms);

package/src/plugins/defaults/memory/v3/sections.ts

@@ -57,7 +57,9 @@ function splitIntoRawSections(body: string): RawSection[] {
  * break on newlines so chunks stay readable. Order is preserved.
  */
 function chunkText(text: string): string[] {
-  if (text.length <= SECTION_CHUNK_CHARS) return [text];
+  if (text.length <= SECTION_CHUNK_CHARS) {
+    return [text];
+  }
 
   const chunks: string[] = [];
   let remaining = text;
@@ -70,7 +72,9 @@ function chunkText(text: string): string[] {
     chunks.push(remaining.slice(0, breakAt));
     remaining = remaining.slice(breakAt).replace(/^\n/, "");
   }
-  if (remaining.length > 0) chunks.push(remaining);
+  if (remaining.length > 0) {
+    chunks.push(remaining);
+  }
   return chunks;
 }
 

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

@@ -284,10 +284,12 @@ async function initLanes(config: AssistantConfig): Promise<ShadowLanes> {
     .map((entry) => entry.slug)
     .filter((slug) => sectionIndex.byArticle.has(slug));
 
-  // Fresh is the modification-recency top-K over the page index with core and
-  // hot excluded (fresh never duplicates the rest of the prefix). Page mtimes
-  // move at consolidation — the same event that invalidates the lanes — so the
-  // set is recomputed exactly when it can have changed.
+  // Fresh is the effective-recency top-K over the page index (`freshAt`:
+  // origin date when declared, else mtime, so backdated imports rank by their
+  // original chronology) with core and hot excluded (fresh never duplicates
+  // the rest of the prefix). Page mtimes move at consolidation, the same
+  // event that invalidates the lanes, so the set is recomputed exactly when
+  // it can have changed.
   const freshSlugs = computeFreshSet(pageIndex.entries, {
     k: tuning.freshSetK,
     excludeSlugs: new Set([...coreSlugs, ...hotSlugs]),
@@ -314,11 +316,12 @@ async function initLanes(config: AssistantConfig): Promise<ShadowLanes> {
   // body into the byte-stable prefix. Disk pages render raw (frontmatter +
   // body) through `renderCard` so `kind: index` pages surface their `links:`
   // map in the card TOC. Each disk card carries its lane annotation; fresh
-  // cards additionally carry the page's last-modified time (an absolute
-  // stamp — it only changes when the page does, so the card stays byte-stable
-  // between lane recomputes).
-  const modifiedAtBySlug = new Map(
-    pageIndex.entries.map((entry) => [entry.slug, entry.modifiedAt]),
+  // cards additionally carry the page's effective-recency time (`freshAt`, so
+  // imported pages display their original date; an absolute stamp that only
+  // changes when the page does, so the card stays byte-stable between lane
+  // recomputes).
+  const freshAtBySlug = new Map(
+    pageIndex.entries.map((entry) => [entry.slug, entry.freshAt]),
   );
   const laneAnnotation = (
     slug: Slug,
@@ -327,19 +330,22 @@ async function initLanes(config: AssistantConfig): Promise<ShadowLanes> {
     if (lane !== "fresh") {
       return `[lane: ${lane}]`;
     }
-    const modifiedAt = modifiedAtBySlug.get(slug);
+    const freshAt = freshAtBySlug.get(slug);
     if (
-      modifiedAt === undefined ||
-      !Number.isFinite(modifiedAt) ||
-      modifiedAt <= 0
+      freshAt === undefined ||
+      freshAt === null ||
+      !Number.isFinite(freshAt)
     ) {
       return "[lane: fresh]";
     }
-    const stamp = new Date(modifiedAt)
+    const stamp = new Date(freshAt)
       .toISOString()
       .slice(0, 16)
       .replace("T", " ");
-    return `[lane: fresh · updated ${stamp} UTC]`;
+    // "dated", not "updated": for origin-dated imports the stamp is the
+    // content's original chronology, not a last-modified time, and claiming
+    // an update would feed the selector false temporal metadata.
+    return `[lane: fresh · dated ${stamp} UTC]`;
   };
   const prefixCards = new Map<Slug, string>();
   for (const [lane, slugs] of [
@@ -472,8 +478,9 @@ function readNowContext(): string | null {
 function buildSituationalContext(): string {
   const now = readNowContext();
   const at = new Date();
-  // Clock time matters, not just the date: fresh cards carry absolute
-  // `updated <time>` stamps, and hour-grain windows ("while I was asleep",
+  // Clock time matters, not just the date: fresh cards carry `dated <time>`
+  // stamps (effective recency, so imports show their content's chronology
+  // rather than write time), and hour-grain windows ("while I was asleep",
   // "this morning") are only computable against a current-time anchor —
   // measured on a state-recall turn, the anchor alone moved selection more
   // than prompt steering did.

package/src/plugins/defaults/memory/v3-eval/__tests__/eval-tally.test.ts

@@ -21,9 +21,15 @@ function buildAllASnapshot(snapWins: number, stageWins: number, tieN: number) {
     key.push({ turn, a: "snapshot", b: "staging" });
     verdicts.push({ turn, winner, scoreA: sa, scoreB: sb });
   };
-  for (let n = 0; n < snapWins; n++) push("A", 7, 6); // snapshot (A) wins by 1
-  for (let n = 0; n < stageWins; n++) push("B", 6, 7); // staging (B) wins by 1
-  for (let n = 0; n < tieN; n++) push("tie", 5, 5);
+  for (let n = 0; n < snapWins; n++) {
+    push("A", 7, 6);
+  } // snapshot (A) wins by 1
+  for (let n = 0; n < stageWins; n++) {
+    push("B", 6, 7);
+  } // staging (B) wins by 1
+  for (let n = 0; n < tieN; n++) {
+    push("tie", 5, 5);
+  }
   return { verdicts, key };
 }
 

package/src/plugins/defaults/memory/v3-eval/eval-packets.ts

@@ -394,6 +394,9 @@ export function mineTurns(
     .innerJoin(conversations, eq(messages.conversationId, conversations.id))
     .where(
       and(
+        // Imported conversations (source LIKE 'import:%') are deliberately
+        // excluded: they predate this assistant's own retrieval behavior and
+        // would skew packets toward foreign conversation styles.
         sql`COALESCE(${conversations.source}, 'user') = 'user'`,
         sql`${conversations.scheduleJobId} IS NULL`,
         ...(exclude.length > 0
@@ -424,6 +427,9 @@ function minePinnedTurns(db: DrizzleDb, pinnedTurnIds: string[]): MinedTurn[] {
     .where(
       and(
         inArray(messages.conversationId, conversationIds),
+        // Imported conversations (source LIKE 'import:%') are deliberately
+        // excluded: they predate this assistant's own retrieval behavior and
+        // would skew packets toward foreign conversation styles.
         sql`COALESCE(${conversations.source}, 'user') = 'user'`,
         sql`${conversations.scheduleJobId} IS NULL`,
       ),

package/src/plugins/defaults/memory/v3-eval/eval-tally.ts

@@ -78,10 +78,14 @@ export interface TallyResult {
  */
 export function binomialTwoSidedSignP(a: number, b: number): number {
   const n = a + b;
-  if (n === 0) return 1;
+  if (n === 0) {
+    return 1;
+  }
   const logFact: number[] = new Array(n + 1);
   logFact[0] = 0;
-  for (let i = 1; i <= n; i++) logFact[i] = logFact[i - 1]! + Math.log(i);
+  for (let i = 1; i <= n; i++) {
+    logFact[i] = logFact[i - 1]! + Math.log(i);
+  }
   const logChoose = (k: number): number =>
     logFact[n]! - logFact[k]! - logFact[n - k]!;
   const hi = Math.max(a, b);
@@ -105,7 +109,9 @@ function winnerSide(
   if (w !== "A" && w !== "B" && w !== "tie") {
     w = v.scoreA > v.scoreB ? "A" : v.scoreB > v.scoreA ? "B" : "tie";
   }
-  if (w === "tie") return "tie";
+  if (w === "tie") {
+    return "tie";
+  }
   return w === "A" ? key.a : key.b;
 }
 
@@ -160,9 +166,13 @@ export function tallyVerdicts(
     panelSizes.push(g.sides.length);
     const nSnap = g.sides.filter((s) => s === "snapshot").length;
     const nStage = g.sides.filter((s) => s === "staging").length;
-    if (nStage > nSnap) stagingWins++;
-    else if (nSnap > nStage) snapshotWins++;
-    else ties++; // tie vote, or equal snapshot/staging votes
+    if (nStage > nSnap) {
+      stagingWins++;
+    } else if (nSnap > nStage) {
+      snapshotWins++;
+    } else {
+      ties++;
+    } // tie vote, or equal snapshot/staging votes
     sumSnap += mean(g.snap);
     sumStage += mean(g.stage);
   }
@@ -172,10 +182,13 @@ export function tallyVerdicts(
   const signTestP = binomialTwoSidedSignP(snapshotWins, stagingWins);
 
   let verdict: TallyResult["verdict"];
-  if (stagingWins > snapshotWins && signTestP < alpha) verdict = "wiki-wins";
-  else if (snapshotWins > stagingWins && signTestP < alpha)
+  if (stagingWins > snapshotWins && signTestP < alpha) {
+    verdict = "wiki-wins";
+  } else if (snapshotWins > stagingWins && signTestP < alpha) {
     verdict = "wiki-loses";
-  else verdict = "tie";
+  } else {
+    verdict = "tie";
+  }
   const gate: "pass" | "fail" = verdict === "wiki-loses" ? "fail" : "pass";
 
   const panel = {

package/src/plugins/defaults/memory/worker.ts

@@ -16,6 +16,11 @@ import { getConfig } from "../../../config/loader.js";
 import { isMemoryEnabled } from "../../../config/memory-v3-gate.js";
 import { rehydratePlatformCredentials } from "../../../config/platform-rehydration.js";
 import { resetDb } from "../../../persistence/db-connection.js";
+import {
+  EMBEDDING_SHUTDOWN_BUDGET_MS,
+  shutdownEmbeddingBackends,
+  terminateEmbeddingWorkersNow,
+} from "../../../persistence/embeddings/embedding-backend.js";
 import { disableStreamSeqStamping } from "../../../runtime/assistant-stream-state.js";
 import { initializeTools } from "../../../tools/registry.js";
 import {
@@ -79,7 +84,18 @@ async function main(): Promise<void> {
   let worker: ReturnType<typeof startMemoryJobsWorkerLoop> | null = null;
   let keepAlive: ReturnType<typeof setInterval> | null = null;
   let disposePidGuard: (() => void) | null = null;
-  const shutdown = (signal: string) => {
+  // Set synchronously by shutdown() so startup below can tell it has been
+  // superseded. Eviction exits immediately, but a signal arriving mid-startup
+  // defers its exit to reap the backend, and without this flag that worker
+  // would fall through to the jobs worker loop, whose
+  // resetRunningJobsToPending() resets the LIVE successor's in-progress jobs
+  // and fires the startup orphan sweeps against its data.
+  let shuttingDown = false;
+  const shutdown = (signal: string, opts: { immediate?: boolean } = {}) => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
     log.info({ signal }, "Memory worker process shutting down");
     worker?.stop();
     if (keepAlive != null) {
@@ -87,25 +103,53 @@ async function main(): Promise<void> {
     }
     disposePidGuard?.();
     cleanupWorkerPidFile(pidPath);
-    process.exit(0);
+
+    // Eviction means a successor is already live and about to reset every
+    // `running` job to `pending`. `worker.stop()` does not cancel the tick
+    // already in flight, so staying alive to reap would let this process keep
+    // executing a job the successor has just reclaimed.
+    //
+    // Exit now, but kill the owned embed worker first. Waiting for the
+    // successor's reclaim sweep to adopt it does not work: eviction is detected
+    // on a 15s poll, by which point that sweep has already run and classified
+    // the child as another live process's, leaving two workers alive.
+    if (opts.immediate) {
+      terminateEmbeddingWorkersNow();
+      process.exit(0);
+    }
+
+    // Signal shutdown: no successor exists, so take the time to reap the ONNX
+    // worker subprocess this process owns rather than leaving an orphan
+    // (JARVIS-1125). `shutdownEmbeddingBackends` enforces its own ceiling, so
+    // this outer race only has to sit above it to stay a backstop rather than
+    // the thing that cuts the reap short.
+    void Promise.race([
+      shutdownEmbeddingBackends().catch((err: unknown) => {
+        log.warn({ err }, "Embedding backend shutdown failed (non-fatal)");
+      }),
+      Bun.sleep(EMBEDDING_SHUTDOWN_BUDGET_MS + 1_000),
+    ]).finally(() => process.exit(0));
   };
 
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("SIGINT", () => shutdown("SIGINT"));
 
-  // Arm the identity guard before the worker loop starts. Its on-arm check
-  // runs synchronously, so a worker superseded during startup runs shutdown()
-  // — which calls process.exit — here, before it dispatches any jobs.
+  // Arm the identity guard before the worker loop starts. Its on-arm check runs
+  // synchronously, so a worker superseded during startup calls shutdown() here,
+  // before it dispatches any jobs.
   disposePidGuard = startWorkerPidFileGuard(pidPath, {
     onEvicted: (reason) => {
-      log.warn(
-        { reason },
-        "Evicted — the PID file no longer names this worker",
-      );
-      shutdown("pid-file-eviction");
+      log.warn({ reason }, "Evicted: the PID file no longer names this worker");
+      shutdown("pid-file-eviction", { immediate: true });
     },
   });
 
+  // shutdown() defers the exit to reap the embedding backend, so startup must
+  // stop itself rather than relying on process.exit having already fired.
+  if (shuttingDown) {
+    return;
+  }
+
   worker = startMemoryJobsWorkerLoop();
 
   // Keep-alive: the worker's setTimeout timers are unref'd, so without

package/src/plugins/defaults/session/injectors.ts

@@ -35,10 +35,16 @@ const backgroundTurnInjector: Injector = {
   name: "background-turn",
   order: DEFAULT_INJECTOR_ORDER.backgroundTurn,
   async produce(ctx: TurnContext): Promise<InjectionBlock | null> {
-    if (!ctx.isBackgroundConversation) return null;
-    if (!ctx.isNonInteractive) return null;
+    if (!ctx.isBackgroundConversation) {
+      return null;
+    }
+    if (!ctx.isNonInteractive) {
+      return null;
+    }
     const inner = getConfig().conversations.backgroundInjection;
-    if (!inner) return null;
+    if (!inner) {
+      return null;
+    }
     return {
       id: "background-turn",
       text: `<background_turn>\n${inner}\n</background_turn>`,
@@ -66,9 +72,13 @@ const subagentStatusInjector: Injector = {
   order: DEFAULT_INJECTOR_ORDER.subagentStatus,
   async produce(ctx: TurnContext): Promise<InjectionBlock | null> {
     const mode = ctx.mode ?? "full";
-    if (mode !== "full") return null;
+    if (mode !== "full") {
+      return null;
+    }
     const block = ctx.subagentStatusBlock;
-    if (!block) return null;
+    if (!block) {
+      return null;
+    }
     return {
       id: "subagent-status",
       text: block,