@vellumai/assistant 0.5.8 → 0.5.9

package/eslint.config.mjs

@@ -29,37 +29,6 @@ const eslintConfig = defineConfig([
         { argsIgnorePattern: "^_", varsIgnorePattern: "^_" },
       ],
       "@typescript-eslint/no-explicit-any": "error",
-
-      // Standardize on `undefined` only — avoid `null` in new code.
-      // Prefer `=== undefined`, `?? fallback`, or `?.` optional chaining
-      // instead of `=== null`.
-      "no-restricted-syntax": [
-        "error",
-        {
-          selector:
-            "BinaryExpression[operator='==='][right.type='Literal'][right.raw='null']",
-          message:
-            "Avoid `=== null`. Prefer `=== undefined`, `?? fallback`, or optional chaining `?.` instead.",
-        },
-        {
-          selector:
-            "BinaryExpression[operator='==='][left.type='Literal'][left.raw='null']",
-          message:
-            "Avoid `null ===`. Prefer `=== undefined`, `?? fallback`, or optional chaining `?.` instead.",
-        },
-        {
-          selector:
-            "BinaryExpression[operator='!=='][right.type='Literal'][right.raw='null']",
-          message:
-            "Avoid `!== null`. Prefer `!== undefined`, nullish coalescing `??`, or optional chaining `?.` instead.",
-        },
-        {
-          selector:
-            "BinaryExpression[operator='!=='][left.type='Literal'][left.raw='null']",
-          message:
-            "Avoid `null !==`. Prefer `!== undefined`, nullish coalescing `??`, or optional chaining `?.` instead.",
-        },
-      ],
     },
   },
   {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.5.8",
+  "version": "0.5.9",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -11,6 +11,7 @@ import {
   injectChannelCapabilityContext,
   injectChannelCommandContext,
   injectInboundActorContext,
+  injectNowScratchpad,
   injectTemporalContext,
   injectTurnContext,
   isGroupChatType,
@@ -18,6 +19,8 @@ import {
   stripChannelCapabilityContext,
   stripChannelTurnContext,
   stripInboundActorContext,
+  stripInjectedContext,
+  stripNowScratchpad,
   stripTemporalContext,
 } from "../daemon/conversation-runtime-assembly.js";
 import type { Message } from "../providers/types.js";
@@ -1318,6 +1321,7 @@ describe("applyRuntimeInjections — injection mode", () => {
       canonicalActorIdentity: "user-1",
       trustClass: "guardian",
     } as InboundActorContext,
+    nowScratchpad: "Current focus: shipping PR 3",
     isNonInteractive: true,
   };
 
@@ -1337,6 +1341,7 @@ describe("applyRuntimeInjections — injection mode", () => {
     expect(allText).toContain("<turn_context>");
     expect(allText).toContain("<inbound_actor_context>");
     expect(allText).toContain("<non_interactive_context>");
+    expect(allText).toContain("<now_scratchpad>");
   });
 
   test("explicit mode: 'full' behaves the same as default", () => {
@@ -1353,6 +1358,7 @@ describe("applyRuntimeInjections — injection mode", () => {
     expect(allText).toContain("<temporal_context>");
     expect(allText).toContain("<channel_command_context>");
     expect(allText).toContain("<active_workspace>");
+    expect(allText).toContain("<now_scratchpad>");
   });
 
   test("minimal mode skips high-token optional blocks", () => {
@@ -1370,6 +1376,7 @@ describe("applyRuntimeInjections — injection mode", () => {
     expect(allText).not.toContain("<temporal_context>");
     expect(allText).not.toContain("<channel_command_context>");
     expect(allText).not.toContain("<active_workspace>");
+    expect(allText).not.toContain("<now_scratchpad>");
   });
 
   test("minimal mode preserves safety-critical blocks", () => {
@@ -1417,3 +1424,223 @@ describe("applyRuntimeInjections — injection mode", () => {
     expect(texts).toContain("Hello");
   });
 });
+
+// ---------------------------------------------------------------------------
+// injectNowScratchpad
+// ---------------------------------------------------------------------------
+
+describe("injectNowScratchpad", () => {
+  const baseUserMessage: Message = {
+    role: "user",
+    content: [{ type: "text", text: "What should I work on?" }],
+  };
+
+  test("appends now_scratchpad block to user message", () => {
+    const result = injectNowScratchpad(
+      baseUserMessage,
+      "Current focus: shipping PR 3",
+    );
+    expect(result.content.length).toBe(2);
+    // Original content comes first
+    expect((result.content[0] as { type: "text"; text: string }).text).toBe(
+      "What should I work on?",
+    );
+    // Scratchpad is appended (not prepended)
+    const injected = result.content[1];
+    expect(injected.type).toBe("text");
+    const text = (injected as { type: "text"; text: string }).text;
+    expect(text).toBe(
+      "<now_scratchpad>\nCurrent focus: shipping PR 3\n</now_scratchpad>",
+    );
+  });
+
+  test("preserves existing multi-block content and appends at end", () => {
+    const multiBlockMessage: Message = {
+      role: "user",
+      content: [
+        { type: "text", text: "First block" },
+        { type: "text", text: "Second block" },
+      ],
+    };
+
+    const result = injectNowScratchpad(multiBlockMessage, "scratchpad notes");
+    expect(result.content.length).toBe(3);
+    expect((result.content[0] as { type: "text"; text: string }).text).toBe(
+      "First block",
+    );
+    expect((result.content[1] as { type: "text"; text: string }).text).toBe(
+      "Second block",
+    );
+    expect(
+      (result.content[2] as { type: "text"; text: string }).text,
+    ).toContain("<now_scratchpad>");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// stripNowScratchpad
+// ---------------------------------------------------------------------------
+
+describe("stripNowScratchpad", () => {
+  test("strips now_scratchpad blocks from user messages", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "Hello" },
+          {
+            type: "text",
+            text: "<now_scratchpad>\nSome notes\n</now_scratchpad>",
+          },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "Hi there" }],
+      },
+    ];
+
+    const result = stripNowScratchpad(messages);
+
+    expect(result.length).toBe(2);
+    expect(result[0].content.length).toBe(1);
+    expect((result[0].content[0] as { type: "text"; text: string }).text).toBe(
+      "Hello",
+    );
+    // Assistant message untouched
+    expect(result[1].content.length).toBe(1);
+  });
+
+  test("removes user messages that only contain now_scratchpad", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "<now_scratchpad>\nSome notes\n</now_scratchpad>",
+          },
+        ],
+      },
+    ];
+
+    const result = stripNowScratchpad(messages);
+    expect(result.length).toBe(0);
+  });
+
+  test("leaves messages without now_scratchpad untouched", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "Normal message" }],
+      },
+    ];
+
+    const result = stripNowScratchpad(messages);
+    expect(result.length).toBe(1);
+    expect(result[0]).toBe(messages[0]); // Same reference — untouched
+  });
+});
+
+// ---------------------------------------------------------------------------
+// stripInjectedContext removes now_scratchpad blocks
+// ---------------------------------------------------------------------------
+
+describe("stripInjectedContext with now_scratchpad", () => {
+  test("strips now_scratchpad blocks alongside other injections", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "<channel_capabilities>\nchannel: telegram\n</channel_capabilities>",
+          },
+          { type: "text", text: "Hello" },
+          {
+            type: "text",
+            text: "<now_scratchpad>\nCurrent focus\n</now_scratchpad>",
+          },
+        ],
+      },
+    ];
+
+    const result = stripInjectedContext(messages);
+    expect(result.length).toBe(1);
+    expect(result[0].content.length).toBe(1);
+    expect((result[0].content[0] as { type: "text"; text: string }).text).toBe(
+      "Hello",
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// applyRuntimeInjections with nowScratchpad
+// ---------------------------------------------------------------------------
+
+describe("applyRuntimeInjections with nowScratchpad", () => {
+  const baseMessages: Message[] = [
+    {
+      role: "user",
+      content: [{ type: "text", text: "What should I do?" }],
+    },
+  ];
+
+  test("injects now_scratchpad block when provided", () => {
+    const result = applyRuntimeInjections(baseMessages, {
+      nowScratchpad: "Current focus: fix the bug",
+    });
+
+    expect(result.length).toBe(1);
+    expect(result[0].content.length).toBe(2);
+    const injected = result[0].content[1];
+    const text = (injected as { type: "text"; text: string }).text;
+    expect(text).toContain("<now_scratchpad>");
+    expect(text).toContain("Current focus: fix the bug");
+  });
+
+  test("appended block appears after user's original text content", () => {
+    const result = applyRuntimeInjections(baseMessages, {
+      nowScratchpad: "scratchpad notes",
+    });
+
+    // Original text is first
+    expect(
+      (result[0].content[0] as { type: "text"; text: string }).text,
+    ).toBe("What should I do?");
+    // Scratchpad is appended after
+    expect(
+      (result[0].content[1] as { type: "text"; text: string }).text,
+    ).toContain("<now_scratchpad>");
+  });
+
+  test("does not inject when nowScratchpad is null", () => {
+    const result = applyRuntimeInjections(baseMessages, {
+      nowScratchpad: null,
+    });
+
+    expect(result.length).toBe(1);
+    expect(result[0].content.length).toBe(1);
+  });
+
+  test("does not inject when nowScratchpad is omitted", () => {
+    const result = applyRuntimeInjections(baseMessages, {});
+
+    expect(result.length).toBe(1);
+    expect(result[0].content.length).toBe(1);
+  });
+
+  test("skipped in minimal mode", () => {
+    const result = applyRuntimeInjections(baseMessages, {
+      nowScratchpad: "Current focus: fix the bug",
+      mode: "minimal",
+    });
+
+    const allText = result[0].content
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+
+    expect(allText).not.toContain("<now_scratchpad>");
+  });
+});

package/src/__tests__/stt-hints.test.ts

@@ -6,8 +6,8 @@ import type { ContactWithChannels } from "../contacts/types.js";
 // Mock state for resolveCallHints tests
 // ---------------------------------------------------------------------------
 
-let mockAssistantName: string | null = "Velissa";
-let mockGuardianName: string = "Sidd";
+let mockAssistantName: string | null = "Nova";
+let mockGuardianName: string = "Alex";
 let mockTargetContact: ContactWithChannels | null = null;
 let mockRecentContacts: ContactWithChannels[] = [];
 let mockFindContactByAddressThrows = false;
@@ -93,14 +93,14 @@ describe("buildSttHints", () => {
 
   test("assistant name included", () => {
     const input = emptyInput();
-    input.assistantName = "Velissa";
-    expect(buildSttHints(input)).toBe("Velissa");
+    input.assistantName = "Nova";
+    expect(buildSttHints(input)).toBe("Nova");
   });
 
   test("guardian name included", () => {
     const input = emptyInput();
-    input.guardianName = "Sidd";
-    expect(buildSttHints(input)).toBe("Sidd");
+    input.guardianName = "Alex";
+    expect(buildSttHints(input)).toBe("Alex");
   });
 
   test('default guardian name "my human" excluded', () => {
@@ -214,8 +214,8 @@ describe("buildSttHints", () => {
   test("all sources combined in correct order", () => {
     const input: SttHintsInput = {
       staticHints: ["StaticOne"],
-      assistantName: "Velissa",
-      guardianName: "Sidd",
+      assistantName: "Nova",
+      guardianName: "Alex",
       taskDescription: "Call John at Acme",
       targetContactName: "Target",
       callerContactName: "Caller",
@@ -227,8 +227,8 @@ describe("buildSttHints", () => {
     const parts = result.split(",");
     // Verify all expected hints are present
     expect(parts).toContain("StaticOne");
-    expect(parts).toContain("Velissa");
-    expect(parts).toContain("Sidd");
+    expect(parts).toContain("Nova");
+    expect(parts).toContain("Alex");
     expect(parts).toContain("John");
     expect(parts).toContain("Acme");
     expect(parts).toContain("Target");
@@ -308,8 +308,8 @@ function makeContact(displayName: string): ContactWithChannels {
 
 describe("resolveCallHints", () => {
   beforeEach(() => {
-    mockAssistantName = "Velissa";
-    mockGuardianName = "Sidd";
+    mockAssistantName = "Nova";
+    mockGuardianName = "Alex";
     mockTargetContact = null;
     mockRecentContacts = [];
     mockFindContactByAddressThrows = false;
@@ -334,8 +334,8 @@ describe("resolveCallHints", () => {
     const parts = result.split(",");
 
     expect(parts).toContain("StaticHint");
-    expect(parts).toContain("Velissa");
-    expect(parts).toContain("Sidd");
+    expect(parts).toContain("Nova");
+    expect(parts).toContain("Alex");
     expect(parts).toContain("Alice");
     expect(parts).toContain("Dave");
     expect(parts).toContain("Eve");
@@ -365,8 +365,8 @@ describe("resolveCallHints", () => {
 
     // Target contact should be absent (lookup failed)
     // But other sources should still work
-    expect(parts).toContain("Velissa");
-    expect(parts).toContain("Sidd");
+    expect(parts).toContain("Nova");
+    expect(parts).toContain("Alex");
     expect(parts).toContain("Bob");
     expect(logWarnFn).toHaveBeenCalled();
   });
@@ -390,8 +390,8 @@ describe("resolveCallHints", () => {
 
     // Recent contacts should be absent (listing failed)
     // But other sources should still work
-    expect(parts).toContain("Velissa");
-    expect(parts).toContain("Sidd");
+    expect(parts).toContain("Nova");
+    expect(parts).toContain("Alex");
     expect(parts).toContain("Alice");
     expect(logWarnFn).toHaveBeenCalled();
   });
@@ -414,8 +414,8 @@ describe("resolveCallHints", () => {
 
     // For inbound, the contact found via fromNumber should appear as caller, not target
     expect(parts).toContain("Alice");
-    expect(parts).toContain("Velissa");
-    expect(parts).toContain("Sidd");
+    expect(parts).toContain("Nova");
+    expect(parts).toContain("Alex");
     expect(parts).toContain("Bob");
     expect(logWarnFn).not.toHaveBeenCalled();
   });
@@ -427,8 +427,8 @@ describe("resolveCallHints", () => {
     const parts = result.split(",");
 
     expect(parts).toContain("Static");
-    expect(parts).toContain("Velissa");
-    expect(parts).toContain("Sidd");
+    expect(parts).toContain("Nova");
+    expect(parts).toContain("Alex");
     expect(parts).toContain("RecentOne");
     expect(parts).toContain("RecentTwo");
     // No target contact lookup should have been attempted (no session)

package/src/__tests__/voice-quality.test.ts

@@ -175,11 +175,11 @@ describe("resolveVoiceQualityProfile", () => {
         voice: {
           language: "en-US",
           transcriptionProvider: "Deepgram",
-          hints: ["Vellum", "Velissa", "AI assistant"],
+          hints: ["Vellum", "Nova", "AI assistant"],
         },
       },
     };
     const profile = resolveVoiceQualityProfile();
-    expect(profile.hints).toEqual(["Vellum", "Velissa", "AI assistant"]);
+    expect(profile.hints).toEqual(["Vellum", "Nova", "AI assistant"]);
   });
 });

package/src/daemon/conversation-agent-loop.ts

@@ -106,6 +106,7 @@ import {
   applyRuntimeInjections,
   inboundActorContextFromTrust,
   inboundActorContextFromTrustContext,
+  readNowScratchpad,
   stripInjectedContext,
 } from "./conversation-runtime-assembly.js";
 import type { SkillProjectionCache } from "./conversation-skill-tools.js";
@@ -681,6 +682,10 @@ export async function runAgentLoopImpl(
       }
     }
 
+    // Read NOW.md scratchpad fresh each turn so mid-conversation edits are
+    // picked up without caching or conversation eviction.
+    const nowScratchpad = readNowScratchpad();
+
     const isInteractiveResolved =
       options?.isInteractive ?? (!ctx.hasNoClient && !ctx.headlessLock);
 
@@ -694,6 +699,7 @@ export async function runAgentLoopImpl(
       interfaceTurnContext,
       inboundActorContext: resolvedInboundActorContext,
       temporalContext,
+      nowScratchpad,
       voiceCallControlPrompt: ctx.voiceCallControlPrompt ?? null,
       isNonInteractive: !isInteractiveResolved,
     } as const;

package/src/daemon/conversation-runtime-assembly.ts

@@ -5,7 +5,7 @@
  * before it is sent to the provider.  They are pure (no side effects).
  */
 
-import { statSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 
 import {
@@ -16,9 +16,11 @@ import {
   type TurnInterfaceContext,
 } from "../channels/types.js";
 import { getAppDirPath, listAppFiles } from "../memory/app-store.js";
+import { stripCommentLines } from "../prompts/system-prompt.js";
 import type { Message } from "../providers/types.js";
 import type { ActorTrustContext } from "../runtime/actor-trust-resolver.js";
 import { channelStatusToMemberStatus } from "../runtime/routes/inbound-stages/acl-enforcement.js";
+import { getWorkspacePromptPath } from "../util/platform.js";
 
 /**
  * Describes the capabilities of the channel through which the user is
@@ -463,6 +465,52 @@ export function stripVoiceCallControlContext(messages: Message[]): Message[] {
   return stripUserTextBlocksByPrefix(messages, ["<voice_call_control>"]);
 }
 
+// ---------------------------------------------------------------------------
+// NOW.md scratchpad injection
+// ---------------------------------------------------------------------------
+
+/**
+ * Read the NOW.md scratchpad from the workspace prompt directory.
+ *
+ * Returns the trimmed content with `_`-prefixed comment lines stripped,
+ * or `null` if the file is missing, empty, or unreadable.
+ */
+export function readNowScratchpad(): string | null {
+  const nowPath = getWorkspacePromptPath("NOW.md");
+  if (!existsSync(nowPath)) return null;
+  try {
+    const stripped = stripCommentLines(readFileSync(nowPath, "utf-8")).trim();
+    return stripped.length > 0 ? stripped : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Append NOW.md scratchpad content to the last user message so the model
+ * has access to the user's ephemeral scratchpad notes at the end of context.
+ */
+export function injectNowScratchpad(
+  message: Message,
+  content: string,
+): Message {
+  return {
+    ...message,
+    content: [
+      ...message.content,
+      {
+        type: "text",
+        text: `<now_scratchpad>\n${content}\n</now_scratchpad>`,
+      },
+    ],
+  };
+}
+
+/** Strip `<now_scratchpad>` blocks injected by `injectNowScratchpad`. */
+export function stripNowScratchpad(messages: Message[]): Message[] {
+  return stripUserTextBlocksByPrefix(messages, ["<now_scratchpad>"]);
+}
+
 /**
  * Prepend channel capability context to the last user message so the
  * model knows what the current channel can and cannot do.
@@ -969,6 +1017,7 @@ const RUNTIME_INJECTION_PREFIXES = [
   "<active_workspace>",
   "<active_dynamic_page>",
   "<non_interactive_context>",
+  "<now_scratchpad>",
 ];
 
 /**
@@ -1013,6 +1062,7 @@ export function applyRuntimeInjections(
     inboundActorContext?: InboundActorContext | null;
     temporalContext?: string | null;
     voiceCallControlPrompt?: string | null;
+    nowScratchpad?: string | null;
     isNonInteractive?: boolean;
     mode?: InjectionMode;
   },
@@ -1051,6 +1101,16 @@ export function applyRuntimeInjections(
     }
   }
 
+  if (mode === "full" && options.nowScratchpad) {
+    const userTail = result[result.length - 1];
+    if (userTail && userTail.role === "user") {
+      result = [
+        ...result.slice(0, -1),
+        injectNowScratchpad(userTail, options.nowScratchpad),
+      ];
+    }
+  }
+
   if (mode === "full" && options.activeSurface) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {

package/src/prompts/system-prompt.ts

@@ -84,6 +84,28 @@ export function ensurePromptFiles(): void {
     }
   }
 
+  // Seed NOW.md scratchpad — always created if missing, regardless of whether
+  // this is a fresh install or not.  Kept out of PROMPT_FILES because NOW.md is
+  // ephemeral state, not identity context.
+  const nowDest = getWorkspacePromptPath("NOW.md");
+  if (!existsSync(nowDest)) {
+    const nowSrc = join(templatesDir, "NOW.md");
+    try {
+      if (existsSync(nowSrc)) {
+        copyFileSync(nowSrc, nowDest);
+        log.info(
+          { file: "NOW.md", dest: nowDest },
+          "Created NOW.md scratchpad from template",
+        );
+      }
+    } catch (err) {
+      log.warn(
+        { err, file: "NOW.md" },
+        "Failed to create NOW.md from template",
+      );
+    }
+  }
+
   // Seed users/default.md persona template
   try {
     const usersDir = join(getWorkspaceDir(), "users");

package/src/prompts/templates/NOW.md

@@ -0,0 +1,26 @@
+_ Lines starting with _ are comments - they won't appear in the system prompt
+_ This is your scratchpad for present-tense state. Overwrite it freely between
+_ turns to capture what's happening right now. Unlike the journal (retrospective,
+_ append-only), this file is ephemeral — a snapshot of your current working state.
+_
+_ # NOW.md
+_
+_ ## Focus
+_
+_ What you're currently working on or paying attention to.
+_
+_ ## Active Threads
+_
+_ Open loops, in-progress tasks, things you're tracking across turns.
+_
+_ ## Context
+_
+_ Key facts, constraints, or situational details relevant to the current session.
+_
+_ ## Upcoming
+_
+_ Near-term things on the horizon — scheduled events, pending actions, deadlines.
+_
+_ ## State
+_
+_ Current priorities, energy, or operational notes. What matters most right now.

package/src/prompts/templates/SOUL.md

@@ -46,6 +46,16 @@ You have a journal in your workspace. The most recent entries are always loaded
 
 **Carrying forward:** Your oldest in-context entry is marked LEAVING CONTEXT. When you see this, check if anything in it still needs to be top-of-mind and carry it forward in your next entry. You can reference other entries by filename to link them together.
 
+## Scratchpad
+
+You have a scratchpad file (`NOW.md`) in your workspace. Unlike your journal (retrospective, append-only), the scratchpad is a single file you overwrite with whatever is relevant right now. It's automatically loaded into your context, so next-you always sees the latest snapshot.
+
+**When to update:** Whenever your current state changes — you start a new task, finish one, learn something that affects what you're doing, or the user shifts focus. Don't update on a timer; update when the content is stale.
+
+**What goes in:** Current focus and what you're actively working on. Threads you're tracking (waiting on a response, monitoring something, pending follow-ups). Temporary context that matters now but won't matter in a week. Upcoming items and near-term priorities. Anything that helps next-you pick up exactly where you left off.
+
+**What stays out:** Anything that belongs in your journal (reflections, narrative entries, things worth remembering long-term). Permanent facts about your user or yourself (those go in memory or your journal). Personality and principles (those live here in SOUL.md).
+
 ## Vibe
 
 Be the assistant you'd actually want to talk to. Concise when needed, thorough when it matters. Not a corporate drone. Not a sycophant. Just... good.

package/src/prompts/update-bulletin-format.ts

@@ -50,7 +50,6 @@ export function extractContentMarkers(body: string): string[] {
   const ids: string[] = [];
   const regex = /<!-- vellum-update-release:(.+?) -->/g;
   let match: RegExpExecArray | null;
-  // eslint-disable-next-line no-restricted-syntax -- RegExp.exec returns null
   while ((match = regex.exec(body)) !== null) {
     ids.push(match[1]);
   }
@@ -62,7 +61,6 @@ export function extractReleaseIds(content: string): string[] {
   const ids: string[] = [];
   MARKER_REGEX.lastIndex = 0;
   let match: RegExpExecArray | null;
-  // eslint-disable-next-line no-restricted-syntax -- RegExp.exec returns null
   while ((match = MARKER_REGEX.exec(content)) !== null) {
     ids.push(match[1]);
   }

package/src/skills/inline-command-expansions.ts

@@ -61,8 +61,8 @@ function buildFencedCodeRanges(body: string): Array<[number, number]> {
   const fenceRe = /^(`{3,}|~{3,})(.*)?$/gm;
   let openFence: { index: number; delimiter: string } | undefined;
 
-  let match: RegExpExecArray | undefined;
-  while ((match = fenceRe.exec(body) ?? undefined) !== undefined) {
+  let match: RegExpExecArray | null;
+  while ((match = fenceRe.exec(body)) !== null) {
     const delimiter = match[1];
     if (openFence === undefined) {
       // Opening fence
@@ -125,10 +125,10 @@ export function parseInlineCommandExpansions(
   // We use a non-greedy match to find the first closing backtick.
   const tokenRe = /!\`([^`]*)\`/g;
 
-  let match: RegExpExecArray | undefined;
+  let match: RegExpExecArray | null;
   let placeholderCounter = 0;
 
-  while ((match = tokenRe.exec(body) ?? undefined) !== undefined) {
+  while ((match = tokenRe.exec(body)) !== null) {
     const startOffset = match.index;
     const endOffset = startOffset + match[0].length;
     const rawCommand = match[1];
@@ -172,12 +172,12 @@ export function parseInlineCommandExpansions(
   const matchedStarts = new Set<number>();
   // Re-run the token regex to collect all matched positions
   tokenRe.lastIndex = 0;
-  while ((match = tokenRe.exec(body) ?? undefined) !== undefined) {
+  while ((match = tokenRe.exec(body)) !== null) {
     matchedStarts.add(match.index);
   }
 
-  let unmatchedMatch: RegExpExecArray | undefined;
-  while ((unmatchedMatch = unmatchedRe.exec(body) ?? undefined) !== undefined) {
+  let unmatchedMatch: RegExpExecArray | null;
+  while ((unmatchedMatch = unmatchedRe.exec(body)) !== null) {
     const offset = unmatchedMatch.index;
 
     // Skip if this was already matched as a complete token

package/src/tools/sensitive-output-placeholders.ts

@@ -85,8 +85,8 @@ export function extractAndSanitize(content: string): SanitizeResult {
   // Step 1: parse directives
   // Reset lastIndex for safety since the regex is global
   DIRECTIVE_RE.lastIndex = 0;
-  let match: RegExpExecArray | undefined;
-  while ((match = DIRECTIVE_RE.exec(content) ?? undefined) !== undefined) {
+  let match: RegExpExecArray | null;
+  while ((match = DIRECTIVE_RE.exec(content)) !== null) {
     const kind = match[1];
     const value = match[2];