gsd-pi 2.76.0 → 2.77.0-dev.2daa994b6

package/src/resources/extensions/remote-questions/tests/command-polling.test.ts

@@ -1,18 +1,31 @@
 /**
- * Tests for startCommandPolling() background interval.
+ * Tests for the REAL `startCommandPolling()` background interval.
  *
- * Framework: node:test + node:assert/strict (CONTRIBUTING.md rules)
+ * Previous version of this file re-implemented `startCommandPolling`
+ * inline (as `makeStartCommandPolling`) and tested the re-implementation.
+ * The file header said exactly that: "Rather than importing the real
+ * startCommandPolling (which calls resolveRemoteConfig and hits the
+ * filesystem / env), we re-implement the same tiny function inline
+ * here using injected fakes." If the real function regressed (wrong
+ * channel gate, missing cleanup, wrong handler invocation), none of
+ * those tests would have failed. See #4806 / #4784.
  *
- * Covers:
- *   - startCommandPolling returns a cleanup function
- *   - Calling cleanup stops further poll invocations
- *   - When no remote channel is configured, a no-op cleanup is returned
+ * Rewrite uses the DI seam now exposed on `startCommandPolling`
+ * (`CommandPollingDeps`) to drive the real function with a stubbed
+ * config resolver, adapter factory, and timer pair.
  */
 
-import test from "node:test";
+import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 
-// ─── Minimal fake timer harness ───────────────────────────────────────────────
+import type { ResolvedConfig } from "../config.ts";
+import {
+  startCommandPolling,
+  type PollingAdapter,
+  type CommandPollingDeps,
+} from "../manager.ts";
+
+// ─── Fake timer harness ───────────────────────────────────────────────────────
 
 interface FakeTimer {
   id: number;
@@ -21,226 +34,223 @@ interface FakeTimer {
   cleared: boolean;
 }
 
-/**
- * Build a fake setInterval / clearInterval pair so tests never actually wait
- * for real time and do not depend on Node's timer subsystem firing order.
- */
 function makeFakeTimers(): {
-  fakeSetInterval: typeof setInterval;
-  fakeClearInterval: typeof clearInterval;
+  setIntervalFn: typeof setInterval;
+  clearIntervalFn: typeof clearInterval;
   timers: FakeTimer[];
   tick: () => void;
 } {
   const timers: FakeTimer[] = [];
   let nextId = 1;
 
-  const fakeSetInterval = (callback: () => void, _ms?: number, ..._args: unknown[]): ReturnType<typeof setInterval> => {
+  const setIntervalFn = ((callback: () => void, ms?: number): ReturnType<typeof setInterval> => {
     const timer: FakeTimer = {
       id: nextId++,
       callback,
-      intervalMs: _ms ?? 0,
+      intervalMs: ms ?? 0,
       cleared: false,
     };
     timers.push(timer);
     return timer.id as unknown as ReturnType<typeof setInterval>;
-  };
+  }) as unknown as typeof setInterval;
 
-  const fakeClearInterval = (id?: ReturnType<typeof clearInterval> | null): void => {
+  const clearIntervalFn = ((id?: ReturnType<typeof clearInterval> | null): void => {
     const timer = timers.find((t) => (t.id as unknown) === id);
     if (timer) timer.cleared = true;
-  };
+  }) as unknown as typeof clearInterval;
 
-  /** Fire all non-cleared timers once (simulates one interval tick). */
   const tick = (): void => {
     for (const timer of timers) {
       if (!timer.cleared) timer.callback();
     }
   };
 
+  return { setIntervalFn, clearIntervalFn, timers, tick };
+}
+
+// ─── Config + adapter stubs ───────────────────────────────────────────────────
+
+function telegramConfig(): ResolvedConfig {
   return {
-    fakeSetInterval: fakeSetInterval as unknown as typeof setInterval,
-    fakeClearInterval: fakeClearInterval as unknown as typeof clearInterval,
-    timers,
-    tick,
-  };
+    channel: "telegram",
+    token: "fake-token",
+    channelId: "fake-channel-id",
+    timeoutMs: 60_000,
+    pollIntervalMs: 1_000,
+  } as ResolvedConfig;
 }
 
-// ─── Fake TelegramAdapter ────────────────────────────────────────────────────
+function slackConfig(): ResolvedConfig {
+  return {
+    channel: "slack",
+    token: "fake-token",
+    channelId: "fake-channel-id",
+    timeoutMs: 60_000,
+    pollIntervalMs: 1_000,
+  } as ResolvedConfig;
+}
 
-function makeFakeAdapter(): {
-  pollCalls: number;
-  pollAndHandleCommands: (basePath: string) => Promise<number>;
-} {
+function makeFakeAdapter(): PollingAdapter & { readonly pollCalls: number } {
   let pollCalls = 0;
-  return {
-    get pollCalls() { return pollCalls; },
+  const adapter = {
+    get pollCalls(): number {
+      return pollCalls;
+    },
     async pollAndHandleCommands(_basePath: string): Promise<number> {
       pollCalls++;
       return 0;
     },
   };
+  return adapter;
 }
 
-// ─── Internal startCommandPolling factory (testable, no real I/O) ────────────
-//
-// Rather than importing the real startCommandPolling (which calls resolveRemoteConfig
-// and hits the filesystem / env), we re-implement the same tiny function inline
-// here using injected fakes. This keeps tests hermetic without mocking globals.
-
-function makeStartCommandPolling(
-  fakeSetInterval: typeof setInterval,
-  fakeClearInterval: typeof clearInterval,
-  adapterPollFn: (basePath: string) => Promise<number>,
-  isConfigured: boolean,
-  intervalMs = 5000,
-): (basePath: string) => () => void {
-  return function startCommandPolling(basePath: string): () => void {
-    if (!isConfigured) {
-      return () => {};
-    }
-
-    const timer = fakeSetInterval(() => {
-      void adapterPollFn(basePath).catch(() => {});
-    }, intervalMs);
-
-    return () => fakeClearInterval(timer);
-  };
-}
-
-// ─── Tests ───────────────────────────────────────────────────────────────────
-
-test("startCommandPolling: returns a cleanup function (callable without error)", () => {
-  const { fakeSetInterval, fakeClearInterval } = makeFakeTimers();
-  const adapter = makeFakeAdapter();
-  const startCommandPolling = makeStartCommandPolling(
-    fakeSetInterval,
-    fakeClearInterval,
-    adapter.pollAndHandleCommands.bind(adapter),
-    true,
-  );
-
-  const cleanup = startCommandPolling("/fake/project");
-
-  assert.equal(typeof cleanup, "function", "Expected startCommandPolling to return a function");
-  // Calling cleanup must not throw
-  assert.doesNotThrow(() => cleanup(), "cleanup() must not throw");
-});
-
-test("startCommandPolling: interval fires the poll callback on tick", async () => {
-  const { fakeSetInterval, fakeClearInterval, tick } = makeFakeTimers();
-  const adapter = makeFakeAdapter();
-  const startCommandPolling = makeStartCommandPolling(
-    fakeSetInterval,
-    fakeClearInterval,
-    adapter.pollAndHandleCommands.bind(adapter),
-    true,
-  );
-
-  startCommandPolling("/fake/project");
-
-  // Before any tick, nothing polled yet
-  assert.equal(adapter.pollCalls, 0);
-
-  // One tick — the callback fires and schedules the async poll
-  tick();
-
-  // Allow the microtask queue to drain so the async poll promise resolves
-  await Promise.resolve();
-
-  assert.equal(adapter.pollCalls, 1, "Expected poll to be called after one tick");
-});
-
-test("startCommandPolling: cleanup stops further poll invocations", async () => {
-  const { fakeSetInterval, fakeClearInterval, timers, tick } = makeFakeTimers();
-  const adapter = makeFakeAdapter();
-  const startCommandPolling = makeStartCommandPolling(
-    fakeSetInterval,
-    fakeClearInterval,
-    adapter.pollAndHandleCommands.bind(adapter),
-    true,
-  );
-
-  const cleanup = startCommandPolling("/fake/project");
-
-  // Tick once to confirm polling works
-  tick();
-  await Promise.resolve();
-  assert.equal(adapter.pollCalls, 1, "Expected 1 poll after first tick");
-
-  // Call cleanup — marks the timer as cleared
-  cleanup();
-
-  // Confirm the underlying timer was cleared
-  assert.equal(timers.length, 1, "Expected exactly one timer to have been registered");
-  assert.equal(timers[0].cleared, true, "Expected timer to be cleared after cleanup()");
-
-  // Tick again — the cleared timer must NOT fire
-  tick();
-  await Promise.resolve();
-  assert.equal(adapter.pollCalls, 1, "Expected no additional polls after cleanup()");
-});
-
-test("startCommandPolling: calling cleanup twice is safe (no throw)", () => {
-  const { fakeSetInterval, fakeClearInterval } = makeFakeTimers();
-  const adapter = makeFakeAdapter();
-  const startCommandPolling = makeStartCommandPolling(
-    fakeSetInterval,
-    fakeClearInterval,
-    adapter.pollAndHandleCommands.bind(adapter),
-    true,
-  );
-
-  const cleanup = startCommandPolling("/fake/project");
-
-  assert.doesNotThrow(() => {
-    cleanup();
-    cleanup();
-  }, "Calling cleanup twice must not throw");
-});
+// ─── Tests against the real startCommandPolling ───────────────────────────────
 
-test("startCommandPolling: returns no-op cleanup when no channel is configured", () => {
-  const { fakeSetInterval, fakeClearInterval, timers } = makeFakeTimers();
-  const adapter = makeFakeAdapter();
-  const startCommandPolling = makeStartCommandPolling(
-    fakeSetInterval,
-    fakeClearInterval,
-    adapter.pollAndHandleCommands.bind(adapter),
-    false, // not configured
-  );
+describe("startCommandPolling (real function via DI seam)", () => {
+  it("returns a cleanup function for a Telegram config", () => {
+    const { setIntervalFn, clearIntervalFn } = makeFakeTimers();
+    const adapter = makeFakeAdapter();
 
-  const cleanup = startCommandPolling("/fake/project");
-
-  assert.equal(typeof cleanup, "function", "Expected a cleanup function even when not configured");
-  assert.equal(timers.length, 0, "Expected no timer to be registered when channel is not configured");
-
-  // The no-op cleanup must not throw
-  assert.doesNotThrow(() => cleanup(), "No-op cleanup must not throw");
-});
-
-test("startCommandPolling: poll errors are swallowed (best-effort)", async () => {
-  const { fakeSetInterval, fakeClearInterval, tick } = makeFakeTimers();
-
-  // Adapter that always rejects
-  let rejectCalls = 0;
-  const throwingPoll = async (_basePath: string): Promise<number> => {
-    rejectCalls++;
-    throw new Error("Simulated network error");
-  };
-
-  const startCommandPolling = makeStartCommandPolling(
-    fakeSetInterval,
-    fakeClearInterval,
-    throwingPoll,
-    true,
-  );
-
-  startCommandPolling("/fake/project");
-
-  // Ticking must not propagate the rejection — the interval is fire-and-forget
-  assert.doesNotThrow(() => tick(), "tick() must not throw even if poll rejects");
+    const deps: CommandPollingDeps = {
+      resolveConfig: () => telegramConfig(),
+      createAdapter: () => adapter,
+      setIntervalFn,
+      clearIntervalFn,
+    };
 
-  // Allow the rejected promise to settle without an unhandled rejection
-  await Promise.resolve();
+    const stop = startCommandPolling("/tmp/project", 5_000, deps);
+    assert.equal(typeof stop, "function", "must return a cleanup function");
+    stop();
+  });
+
+  it("invokes the adapter's pollAndHandleCommands on each tick", async () => {
+    const { setIntervalFn, clearIntervalFn, tick } = makeFakeTimers();
+    const adapter = makeFakeAdapter();
+
+    const stop = startCommandPolling("/tmp/project", 5_000, {
+      resolveConfig: () => telegramConfig(),
+      createAdapter: () => adapter,
+      setIntervalFn,
+      clearIntervalFn,
+    });
+
+    assert.equal(adapter.pollCalls, 0, "no poll before any tick");
+
+    tick();
+    // Yield so the async adapter call settles before we assert.
+    await Promise.resolve();
+    await Promise.resolve();
+    assert.equal(adapter.pollCalls, 1, "one tick → one poll");
+
+    tick();
+    tick();
+    await Promise.resolve();
+    await Promise.resolve();
+    assert.equal(adapter.pollCalls, 3, "three ticks → three polls");
+
+    stop();
+  });
+
+  it("cleanup stops further polls", async () => {
+    const { setIntervalFn, clearIntervalFn, tick } = makeFakeTimers();
+    const adapter = makeFakeAdapter();
+
+    const stop = startCommandPolling("/tmp/project", 5_000, {
+      resolveConfig: () => telegramConfig(),
+      createAdapter: () => adapter,
+      setIntervalFn,
+      clearIntervalFn,
+    });
+
+    tick();
+    await Promise.resolve();
+    await Promise.resolve();
+    const pollsBeforeStop = adapter.pollCalls;
+    assert.ok(pollsBeforeStop > 0, "at least one poll before stop");
+
+    stop();
+
+    tick();
+    tick();
+    await Promise.resolve();
+    await Promise.resolve();
+    assert.equal(
+      adapter.pollCalls,
+      pollsBeforeStop,
+      "no additional polls after stop() — cleared interval must stop ticking",
+    );
+  });
+
+  it("returns a no-op when no remote channel is configured", () => {
+    const { setIntervalFn, clearIntervalFn, timers } = makeFakeTimers();
+    const adapter = makeFakeAdapter();
+
+    const stop = startCommandPolling("/tmp/project", 5_000, {
+      resolveConfig: () => null,
+      createAdapter: () => adapter,
+      setIntervalFn,
+      clearIntervalFn,
+    });
+
+    assert.equal(typeof stop, "function", "still returns a function");
+    assert.equal(
+      timers.length,
+      0,
+      "no interval registered when config is absent",
+    );
+    assert.doesNotThrow(() => stop());
+  });
+
+  it("returns a no-op for non-Telegram channels (e.g. Slack)", () => {
+    const { setIntervalFn, clearIntervalFn, timers } = makeFakeTimers();
+    const adapter = makeFakeAdapter();
+    let adapterCreated = false;
+
+    const stop = startCommandPolling("/tmp/project", 5_000, {
+      resolveConfig: () => slackConfig(),
+      createAdapter: () => {
+        adapterCreated = true;
+        return adapter;
+      },
+      setIntervalFn,
+      clearIntervalFn,
+    });
+
+    assert.equal(
+      timers.length,
+      0,
+      "no interval registered for non-Telegram channel",
+    );
+    assert.equal(
+      adapterCreated,
+      false,
+      "adapter must not be instantiated when channel is unsupported",
+    );
+    stop();
+  });
+
+  it("does not surface adapter polling errors (best-effort)", async () => {
+    const { setIntervalFn, clearIntervalFn, tick } = makeFakeTimers();
+    const adapter: PollingAdapter = {
+      async pollAndHandleCommands(_basePath: string): Promise<number> {
+        throw new Error("network hiccup");
+      },
+    };
 
-  assert.equal(rejectCalls, 1, "Expected poll to have been called once");
+    const stop = startCommandPolling("/tmp/project", 5_000, {
+      resolveConfig: () => telegramConfig(),
+      createAdapter: () => adapter,
+      setIntervalFn,
+      clearIntervalFn,
+    });
+
+    // Tick must not throw; the `.catch(() => {})` in production code
+    // swallows the rejection so one bad network call doesn't crash
+    // the polling loop.
+    assert.doesNotThrow(() => tick());
+    await Promise.resolve();
+    await Promise.resolve();
+
+    stop();
+  });
 });

package/src/resources/extensions/search-the-web/command-search-provider.ts

@@ -8,7 +8,7 @@
  * All provider logic lives in provider.ts (S01) — this is pure UI wiring.
  */
 
-import { isAnthropicApi } from '@gsd/pi-ai'
+import { supportsNativeWebSearch } from './native-search.js'
 import type { ExtensionAPI } from '@gsd/pi-coding-agent'
 import type { AutocompleteItem } from '@gsd/pi-tui'
 import {
@@ -91,9 +91,10 @@ export function registerSearchProviderCommand(pi: ExtensionAPI): void {
 
       setSearchProviderPreference(chosen)
       const effective = resolveSearchProvider()
-      // Gate on api (#4478 / ADR-012): covers claude-code, anthropic-vertex, and
-      // other Anthropic-fronting transports — not just the plain `anthropic` provider.
-      const isAnthropic = isAnthropicApi(ctx.model)
+      // Gate on api shape + provider allowlist: the info note must match the
+      // actual runtime behavior in native-search.ts. Claude served via copilot
+      // / minimax / kimi is anthropic-shaped but does NOT run native search.
+      const isAnthropic = supportsNativeWebSearch(ctx.model)
       const nativeNote = isAnthropic ? '\nNote: Native Anthropic web search is also active (automatic, no API key needed).' : ''
       ctx.ui.notify(
         `Search provider set to ${chosen}. Effective provider: ${effective ?? 'none (no API keys)'}${nativeNote}`,

package/src/resources/extensions/search-the-web/native-search.ts

@@ -17,6 +17,41 @@ export const CUSTOM_SEARCH_TOOL_NAMES = ["search-the-web", "search_and_read", "g
 /** Thinking block types that require signature validation by the API */
 const THINKING_TYPES = new Set(["thinking", "redacted_thinking"]);
 
+/**
+ * Providers whose Anthropic-Messages endpoint is known to accept the native
+ * `web_search_20250305` server tool. Anthropic-shaped transports NOT in this
+ * set (github-copilot, minimax, kimi-coding, opencode, vercel-ai-gateway,
+ * etc.) route Claude or Claude-compatible models through the Messages API
+ * but do NOT expose the server-side search tool — injecting it yields a
+ * 400 "unsupported_value" from their endpoints (regression from #4492).
+ *
+ * Keep this allowlist tight — err on the side of custom/Brave search rather
+ * than a runtime 400. Add a provider here only after confirming its endpoint
+ * accepts the tool type.
+ */
+const NATIVE_WEB_SEARCH_PROVIDERS = new Set([
+  "anthropic",
+  "claude-code",
+  "anthropic-vertex",
+  "vercel-ai-gateway",
+]);
+
+/**
+ * True when the model is an Anthropic-shaped transport AND the provider is
+ * known to accept the native `web_search_20250305` tool. Gate both on api
+ * shape (#4478 / ADR-012) and on provider identity (#444 regression guard
+ * and #4492 scope correction) — provider-level discrimination is legitimate
+ * per ADR-012 for credential/behavior differences that api shape can't
+ * express.
+ */
+export function supportsNativeWebSearch(
+  model: { api?: string; provider?: string } | null | undefined
+): boolean {
+  if (!isAnthropicApi(model)) return false;
+  const provider = model?.provider;
+  return typeof provider === "string" && NATIVE_WEB_SEARCH_PROVIDERS.has(provider);
+}
+
 /**
  * Maximum number of native web searches allowed per session (agent unit).
  * The Anthropic API's `max_uses` is per-request — it resets on each API call.
@@ -95,10 +130,11 @@ export function registerNativeSearchHooks(pi: NativeSearchPI): { getIsAnthropic:
   pi.on("model_select", async (event: any, ctx: any) => {
     modelSelectFired = true;
     const wasAnthropic = isAnthropicProvider;
-    // Gate on `api` not `provider` (#4478 / ADR-012): covers claude-code OAuth,
-    // anthropic-vertex, and Vercel-gateway-hosted Anthropic — all serve the
-    // Messages API and accept the native web_search tool.
-    isAnthropicProvider = isAnthropicApi(event.model);
+    // Gate on api shape AND provider allowlist: direct Anthropic, claude-code
+    // OAuth, and anthropic-vertex accept `web_search_20250305`; copilot /
+    // minimax / kimi / opencode route Claude-compat models through the same
+    // wire protocol but reject the server-side tool (#4492 regression).
+    isAnthropicProvider = supportsNativeWebSearch(event.model);
 
     const hasBrave = !!process.env.BRAVE_API_KEY;
 
@@ -145,17 +181,17 @@ export function registerNativeSearchHooks(pi: NativeSearchPI): { getIsAnthropic:
     // modelsAreEqual suppresses model_select AND the SDK doesn't pass model.
     const eventModel = event.model as { provider?: string; api?: string } | undefined;
     let isAnthropic: boolean;
-    if (eventModel?.api) {
-      // Preferred path: gate on wire protocol (#4478 / ADR-012).
-      isAnthropic = isAnthropicApi(eventModel);
-    } else if (eventModel?.provider) {
-      // Fallback for event shapes that carry provider but not api — only plain
-      // `anthropic` maps unambiguously without the api field. Other Anthropic
-      // transports will arrive via the modelSelectFired or model-name branch.
-      isAnthropic = eventModel.provider === "anthropic";
+    if (eventModel?.api || eventModel?.provider) {
+      // Preferred path: gate on api shape + provider allowlist. Both fields
+      // are authoritative when present — do NOT fall back to the model-name
+      // heuristic, which would misclassify copilot-served Claude as Anthropic
+      // (#444 regression) or minimax-served Claude-compat as Anthropic (#4492).
+      isAnthropic = supportsNativeWebSearch(eventModel);
     } else if (modelSelectFired) {
       isAnthropic = isAnthropicProvider;
     } else {
+      // Last resort: session-restore paths where the SDK doesn't pass model.
+      // The model-name prefix is best-effort and assumes direct Anthropic.
       const modelName = typeof payload.model === "string" ? payload.model : "";
       isAnthropic = modelName.startsWith("claude-");
     }

package/src/resources/extensions/shared/cmux-events.ts

@@ -0,0 +1,59 @@
+// GSD-2 — Shared cmux event channel contracts
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+/**
+ * Neutral event channel module for gsd<->cmux IPC.
+ * Both gsd and cmux import from here — neither imports the other directly.
+ * Per ADR-006 Phase 0: event-based decoupling.
+ */
+
+export const CMUX_CHANNELS = {
+  SIDEBAR: "cmux:sidebar",
+  LOG: "cmux:log",
+  LIFECYCLE: "cmux:lifecycle",
+} as const;
+
+/** Migrated from cmux/index.ts (D-07) — shared by both gsd and cmux. */
+export type CmuxLogLevel = "info" | "progress" | "success" | "warning" | "error";
+
+// ── Structural types (D-05): cmux defines only what it needs ──
+
+export interface CmuxPreferencesInput {
+  cmux?: {
+    enabled?: boolean;
+    notifications?: boolean;
+    sidebar?: boolean;
+    splits?: boolean;
+    browser?: boolean;
+  };
+}
+
+export interface CmuxStateInput {
+  phase: string;
+  activeMilestone?: { id: string };
+  activeSlice?: { id: string };
+  activeTask?: { id: string };
+  progress?: {
+    milestones: { done: number; total: number };
+    slices?: { done: number; total: number };
+    tasks?: { done: number; total: number };
+  };
+}
+
+// ── Event payloads ──
+
+export interface CmuxSidebarEvent {
+  action: "sync" | "clear";
+  preferences?: CmuxPreferencesInput;
+  state?: CmuxStateInput;
+}
+
+export interface CmuxLogEvent {
+  preferences?: CmuxPreferencesInput;
+  message: string;
+  level: CmuxLogLevel;
+}
+
+export interface CmuxLifecycleEvent {
+  action: "markPromptShown";
+}

package/src/resources/extensions/shared/rtk-session-stats.ts

@@ -2,7 +2,6 @@ import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { gsdRoot } from "../gsd/paths.js";
 import { formatTokenCount } from "./format-utils.js";
 import { buildRtkEnv, isRtkEnabled, resolveRtkBinaryPath } from "./rtk.js";
 
@@ -46,7 +45,7 @@ interface BaselineStore {
 let cachedSummary: { at: number; binaryPath: string; summary: RtkGainSummary | null } | null = null;
 
 function getRuntimeDir(basePath: string): string {
-  return join(gsdRoot(basePath), "runtime");
+  return join(basePath, ".gsd", "runtime");
 }
 
 function getBaselinesPath(basePath: string): string {

package/src/resources/extensions/shared/tests/interview-preview.test.ts

@@ -56,14 +56,22 @@ describe("preview column rendering", () => {
     assert.ok(hasContent, "At least one rendered line should have visible content");
   });
 
-  it("Markdown component renders code blocks", () => {
+  it("Markdown component renders code blocks — preserves the source text", () => {
     const mdTheme = getMarkdownTheme();
     const md = new Markdown("```ts\nconst x = 1;\n```", 1, 0, mdTheme);
     const lines = md.render(40);
     assert.ok(lines.length > 0);
     const joined = lines.join("\n");
-    // The rendered output should contain the code content somewhere
-    assert.ok(joined.includes("const") || joined.includes("x"), "Code block content should be present");
+    // Previous assertion was `includes("const") || includes("x")` — the
+    // `x` branch matched any ANSI rendering incidentally containing the
+    // letter (box borders, tab markers, even fallbackColor's `x` token),
+    // making it a near-tautology. Assert on a distinctive combined
+    // source fragment so a regression that silently swallows the code
+    // block body actually fails.
+    assert.ok(
+      joined.includes("const") && joined.includes("x = 1"),
+      `rendered code block must preserve source tokens. got:\n${joined}`,
+    );
   });
 
   it("Markdown component respects width constraint", () => {