@pi-archimedes/diff 2.12.0 → 2.14.0

package/README.md

@@ -24,10 +24,10 @@ New to Pi? Pi itself is a one-time global install and needs Node.js ≥ 22.19.0:
 npm install -g --ignore-scripts @earendil-works/pi-coding-agent
 ```
 
-After installing Pi, choose one installation command above, then `cd` into your project and run `pi`. Inside the session, `/login` signs you in and `/model` picks a model — the [setup section](https://github.com/danielcherubini/pi-archimedes#setup) walks through the first run. A running session picks the diff renderer up with `/reload`.
+After installing Pi, choose one installation command above, then `cd` into your project and run `pi`. Inside the session, `/login` signs you in and `/model` picks a model — the [setup section](https://github.com/archimedes-codes/pi-archimedes#setup) walks through the first run. A running session picks the diff renderer up with `/reload`.
 
 <div align="center">
-  <img src="https://raw.githubusercontent.com/danielcherubini/pi-archimedes/main/docs/images/diff-edit.png" width="700" alt="Shiki syntax-highlighted split diff">
+  <img src="https://raw.githubusercontent.com/archimedes-codes/pi-archimedes/main/docs/images/diff-edit.png" width="700" alt="Shiki syntax-highlighted split diff">
 </div>
 
 ## What you get
@@ -43,7 +43,7 @@ The renderer displays `edit` and `write` tool changes in the tool UI, including
 
 ## Appearance
 
-Standalone, the renderer runs on fixed defaults — the `github-dark` theme, a 150-column minimum for split view, 60 code columns per side, and line-wrap safety checks enabled — and it does **not** read settings, because standalone has no config reader. In the [suite](https://github.com/danielcherubini/pi-archimedes), its `archimedes.diff` namespace supplies the settings through the suite's config reader:
+Standalone, the renderer runs on fixed defaults — the `github-dark` theme, a 150-column minimum for split view, 60 code columns per side, and line-wrap safety checks enabled — and it does **not** read settings, because standalone has no config reader. In the [suite](https://github.com/archimedes-codes/pi-archimedes), its `archimedes.diff` namespace supplies the settings through the suite's config reader:
 
 | Setting | Type | Default | Description |
 |---------|------|---------|-------------|
@@ -56,4 +56,4 @@ The palette is derived from the chosen Shiki theme; it does **not** automaticall
 
 On/off is managed by the suite: toggle via `/plugins` (`archimedes.diff.enabled`, default on).
 
-← [Back to pi-archimedes](https://github.com/danielcherubini/pi-archimedes)
+← [Back to pi-archimedes](https://github.com/archimedes-codes/pi-archimedes)

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@pi-archimedes/diff",
-  "version": "2.12.0",
+  "version": "2.14.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/danielcherubini/pi-archimedes.git"
+    "url": "https://github.com/archimedes-codes/pi-archimedes.git"
   },
   "type": "module",
   "keywords": [
@@ -37,6 +37,6 @@
     "extensions": [
       "./src/index.ts"
     ],
-    "image": "https://raw.githubusercontent.com/danielcherubini/pi-archimedes/main/docs/images/diff-edit.png"
+    "image": "https://raw.githubusercontent.com/archimedes-codes/pi-archimedes/main/docs/images/diff-edit.png"
   }
 }

package/src/ansi/codes.test.ts

@@ -19,7 +19,6 @@ import {
 	DEFAULT_DIFF_BG,
 	themeCacheKey,
 	resolveDiffColors,
-	resetDiffColors,
 } from "./codes.js";
 
 // ── Exported constants ──────────────────────────────────────────────────────
@@ -185,19 +184,16 @@ describe("themeCacheKey", () => {
 
 describe("resolveDiffColors", () => {
 	it("returns DEFAULT_DIFF_COLORS when no theme", () => {
-		resetDiffColors();
 		const result = resolveDiffColors(undefined);
 		expect(result).toEqual(DEFAULT_DIFF_COLORS);
 	});
 
 	it("returns DEFAULT_DIFF_COLORS when theme lacks getFgAnsi", () => {
-		resetDiffColors();
 		const result = resolveDiffColors({ fg: () => "" });
 		expect(result).toEqual(DEFAULT_DIFF_COLORS);
 	});
 
 	it("returns theme-derived colors when theme has getFgAnsi", () => {
-		resetDiffColors();
 		const theme = {
 			getFgAnsi: (token: string) => {
 				if (token === "toolDiffAdded") return "\x1b[38;2;50;200;50m";
@@ -218,7 +214,6 @@ describe("resolveDiffColors", () => {
 		// it (pre-0.99.0) substituted a colour where the theme had said "the
 		// terminal's own". Both readings agree on the fix: a terminal default is
 		// an answer, not a missing value.
-		resetDiffColors();
 		for (const token of ["", "\x1b[39m", "\x1b[0m"]) {
 			const result = resolveDiffColors({ getFgAnsi: () => token });
 			expect(result).toEqual({ fgAdd: token, fgDel: token, fgCtx: token });
@@ -226,7 +221,6 @@ describe("resolveDiffColors", () => {
 	});
 
 	it("substitutes the hardcoded fallback per token, only where the theme has no answer", () => {
-		resetDiffColors();
 		const theme = {
 			getFgAnsi: (token: string) => {
 				if (token === "toolDiffAdded") return "\x1b[38;2;50;200;50m";
@@ -242,44 +236,7 @@ describe("resolveDiffColors", () => {
 	});
 
 	it("keeps the hardcoded set for the no-theme-object path", () => {
-		resetDiffColors();
 		expect(resolveDiffColors(undefined)).toEqual(DEFAULT_DIFF_COLORS);
 		expect(resolveDiffColors({})).toEqual(DEFAULT_DIFF_COLORS);
 	});
 });
-
-// ── resetDiffColors ─────────────────────────────────────────────────────────
-
-describe("resetDiffColors", () => {
-	it("clears cache so subsequent call re-derives", () => {
-		const theme = {
-			getFgAnsi: (token: string) => {
-				if (token === "toolDiffAdded") return "\x1b[38;2;50;200;50m";
-				if (token === "toolDiffRemoved") return "\x1b[38;2;200;50;50m";
-				if (token === "toolDiffContext") return "\x1b[38;2;100;100;100m";
-				return "";
-			},
-		};
-
-		// First call derives colors
-		const result1 = resolveDiffColors(theme);
-		expect(result1.fgAdd).toBe("\x1b[38;2;50;200;50m");
-
-		// Reset clears cache
-		resetDiffColors();
-
-		// Now change the theme
-		const newTheme = {
-			getFgAnsi: (token: string) => {
-				if (token === "toolDiffAdded") return "\x1b[38;2;10;100;10m";
-				if (token === "toolDiffRemoved") return "\x1b[38;2;100;10;10m";
-				if (token === "toolDiffContext") return "\x1b[38;2;50;50;50m";
-				return "";
-			},
-		};
-
-		// After reset, new theme should be picked up
-		const result2 = resolveDiffColors(newTheme);
-		expect(result2.fgAdd).toBe("\x1b[38;2;10;100;10m");
-	});
-});

package/src/ansi/codes.ts

@@ -56,9 +56,6 @@ export const DEFAULT_DIFF_BG: DiffBg = {
 	divider: `${FG_RULE}│\x1b[0m`,
 };
 
-// Theme cache key state — lives here since it's used by resolveDiffColors.
-let _lastThemeKey: string | undefined;
-
 // ---------------------------------------------------------------------------
 // Regex patterns
 // ---------------------------------------------------------------------------
@@ -84,11 +81,6 @@ export const DEFAULT_DIFF_COLORS: DiffColors = { fgAdd: FG_ADD, fgDel: FG_DEL, f
 // Theme-aware color resolution
 // ---------------------------------------------------------------------------
 
-/** Reset auto-derived colors — call when theme changes. */
-export function resetDiffColors(): void {
-	_lastThemeKey = undefined;
-}
-
 export function themeCacheKey(theme?: any): string {
 	if (!theme?.fg) return "no-theme";
 	const fgKeys = [
@@ -130,12 +122,6 @@ function themeFgAnsi(theme: any, token: string): string | undefined {
 }
 
 export function resolveDiffColors(theme?: any): DiffColors {
-	const themeKey = themeCacheKey(theme);
-
-	// Re-derive theme key cache (bg colors are now passed explicitly via DiffBg)
-	if (themeKey !== _lastThemeKey) {
-		_lastThemeKey = themeKey;
-	}
 	if (!theme?.getFgAnsi) return DEFAULT_DIFF_COLORS;
 	// Per token, so one unknown token cannot drag the whole row back to the
 	// hardcoded set.

package/src/ansi/index.ts

@@ -7,7 +7,7 @@ export {
 	DEFAULT_DIFF_BG,
 	ANSI_RE, ANSI_CAPTURE_RE, ANSI_PARAM_CAPTURE_RE,
 	DEFAULT_DIFF_COLORS,
-	resetDiffColors, themeCacheKey, resolveDiffColors,
+	themeCacheKey, resolveDiffColors,
 	deriveBgFromTheme,
 	type DiffBg,
 	type DiffColors,

package/src/config-threading.test.ts

@@ -0,0 +1,175 @@
+/**
+ * Config threading (issue #163, the #156 shape-parity card).
+ *
+ * `registerDiffTools(pi, getTheme, readConfig)` used to park `readConfig` in a
+ * module-scope binding and re-point two submodule getters at it. Two sessions in
+ * one process therefore shared ONE config slot: after the second registration,
+ * the first session's rows rendered with the second session's `diffTheme` and
+ * split thresholds — measured flipping a 200-column render from split to unified.
+ *
+ * The pin drives INSTALLED RENDERERS, never a leaf function. Passing a config
+ * straight to `shouldUseSplit` cannot observe the shared holder, so a test
+ * written against the leaf reads green on both the broken and the fixed tree and
+ * pins nothing.
+ *
+ * Red on the base tree: session A's reader stops firing the moment session B
+ * registers (`expected N to be greater than N`). Green once the reader is
+ * captured per registration.
+ */
+
+import { describe, it, expect } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerDiffTools } from "./index.js";
+import type { DiffRenderConfig } from "./render/index.js";
+
+/**
+ * A `pi` handle that collects every resolver, the way pi collects a LIST of them
+ * per extension (same shape as `src/tools/register.test.ts`).
+ */
+function fakePi() {
+  const renderers: ((name: string, next: () => any) => any)[] = [];
+  const pi = {
+    registerTool: () => {},
+    registerToolRenderer: (r: (name: string, next: () => any) => any) => {
+      renderers.push(r);
+    },
+    on: () => () => {},
+  } as unknown as ExtensionAPI;
+  return { pi, renderers };
+}
+
+/**
+ * Resolve the way pi does: fold every registered resolver over the previous
+ * answer. Both installers push a resolver, so capturing only the last one would
+ * overwrite the `edit` answer — the fold is what keeps it.
+ */
+function resolveTool(
+  resolvers: readonly ((name: string, next: () => any) => any)[],
+  toolName: string,
+) {
+  let out: any = { renderShell: "default" };
+  for (const r of resolvers) out = r(toolName, () => out) ?? out;
+  return out;
+}
+
+// The theme stub from `src/tools/edit.test.ts` — a token-addressable fake, so
+// nothing here decides a colour by reading an escape sequence.
+const theme = {
+  fg: (token: string, text?: string) =>
+    text === undefined ? `[${token}]` : `[${token}:${text}]`,
+  bold: (text: string) => `**${text}**`,
+  bg: (_token: string, text: string) => text,
+  italic: (text: string) => text,
+} as any;
+
+/**
+ * A FRESH context per call, exactly as pi hands one to a renderer. A reused ctx
+ * would let the `ctx.state._pk` memo short-circuit the row before it ever built
+ * a component, and the read we are counting would not happen.
+ */
+function freshCtx() {
+  return {
+    state: {},
+    outputPad: 1,
+    argsComplete: true,
+    lastComponent: undefined,
+    invalidate: () => {},
+    isError: false,
+    expanded: false,
+  } as any;
+}
+
+/** Render a row the way pi does: build it, then draw it at a real width. */
+function drawRow(renderers: any, args: any, width: number): string[] {
+  const component = renderers.renderCall(args, theme, freshCtx());
+  return component.render(width);
+}
+
+/** Let the component's async render promise run to completion. */
+async function settle(): Promise<void> {
+  for (let i = 0; i < 5; i++) await new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+function workspace(dir: string, name: string, contents: string): string {
+  const file = path.join(dir, name);
+  writeFileSync(file, contents);
+  return file;
+}
+
+describe("config threading across two sessions in one process", () => {
+  it("keeps session A reading its own config after session B registers (#163)", async () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "diff-threading-"));
+    try {
+      let readsA = 0;
+      let readsB = 0;
+
+      // A wants a wide-enough terminal for the split view and a light theme.
+      const configA: DiffRenderConfig = {
+        diffTheme: "github-light",
+        diffSplitMinWidth: 100,
+        diffSplitMinCodeWidth: 30,
+        diffSplitWrapCheck: false,
+      };
+      // B wants a terminal wider than any real one: every render falls back to
+      // unified. If A inherits B's reader, A's split view disappears.
+      const configB: DiffRenderConfig = {
+        diffTheme: "dracula",
+        diffSplitMinWidth: 4000,
+        diffSplitMinCodeWidth: 30,
+        diffSplitWrapCheck: false,
+      };
+
+      const readerA = () => {
+        readsA++;
+        return configA;
+      };
+      const readerB = () => {
+        readsB++;
+        return configB;
+      };
+
+      const sessionA = fakePi();
+      registerDiffTools(sessionA.pi, () => theme, readerA);
+
+      const editA = resolveTool(sessionA.renderers, "edit");
+      expect(typeof editA?.renderCall).toBe("function");
+
+      const first = workspace(dir, "first.ts", "const a = 1;\n");
+      drawRow(
+        editA,
+        { path: first, oldText: "const a = 1;\n", newText: "const b = 2;\n" },
+        200,
+      );
+      await settle();
+
+      const readsAfterFirst = readsA;
+      expect(readsAfterFirst).toBeGreaterThan(0);
+
+      // A second session, on a DIFFERENT `pi` handle, with a different reader.
+      const sessionB = fakePi();
+      registerDiffTools(sessionB.pi, () => theme, readerB);
+      expect(resolveTool(sessionB.renderers, "edit")?.renderCall).toBeTypeOf("function");
+
+      // A brand new `edit` row, still rendered by A's resolvers.
+      const second = workspace(dir, "second.ts", "const c = 3;\n");
+      drawRow(
+        editA,
+        { path: second, oldText: "const c = 3;\n", newText: "const d = 4;\n" },
+        200,
+      );
+      await settle();
+
+      // A's rows must still ask A. On the shared-holder tree this reads
+      // `expected N to be greater than N`: B's registration re-pointed the
+      // module binding and A's reader never fires again.
+      expect(readsA).toBeGreaterThan(readsAfterFirst);
+      // A's rows must not have been rendered by B's reader either.
+      expect(readsB).toBe(0);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/diff-component.ts

@@ -6,7 +6,7 @@ import type { Theme } from "@earendil-works/pi-coding-agent";
 import * as Ansi from "./ansi/index.js";
 import type { DiffBg, DiffColors } from "./ansi/index.js";
 import { DEFAULT_DIFF_COLORS, DEFAULT_DIFF_BG, deriveBgFromTheme } from "./ansi/index.js";
-import { renderSplitLines, MAX_RENDER_LINES } from "./render/index.js";
+import { renderSplitLines, MAX_RENDER_LINES, type DiffRenderConfig } from "./render/index.js";
 import type { ParsedDiff } from "./core/diff.js";
 
 // ---------------------------------------------------------------------------
@@ -31,9 +31,10 @@ import type { ParsedDiff } from "./core/diff.js";
  *
  * ```ts
  * renderResult(result, options, theme, context) {
+ *   const cfg = readConfig();
  *   const d = result.details;
  *   if (d?._type === "diff") {
- *     const comp = context.lastComponent ?? new DiffComponent(d.diff, d.language, theme);
+ *     const comp = context.lastComponent ?? new DiffComponent(d.diff, d.language, theme, cfg);
  *     return comp;
  *   }
  * }
@@ -43,6 +44,8 @@ export class DiffComponent implements Component {
 	private diff: ParsedDiff;
 	private language: BundledLanguage | undefined;
 	private theme: Theme;
+	/** The config the row was registered with — never read from module state. */
+	private config: DiffRenderConfig;
 	private maxLines: number;
 
 	/** Box wrapper with base background — makes the diff self-contained. */
@@ -64,11 +67,13 @@ export class DiffComponent implements Component {
 		diff: ParsedDiff,
 		language: BundledLanguage | undefined,
 		theme: Theme,
+		config: DiffRenderConfig,
 		maxLines: number = MAX_RENDER_LINES,
 	) {
 		this.diff = diff;
 		this.language = language;
 		this.theme = theme;
+		this.config = config;
 		this.maxLines = maxLines;
 
 		// Box provides base background so the diff is self-contained.
@@ -122,6 +127,7 @@ export class DiffComponent implements Component {
 			this.diff,
 			this.language,
 			width,
+			this.config,
 			this.maxLines,
 			dc,
 			dbg,

package/src/index.ts

@@ -7,11 +7,9 @@
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import type { Component, SettingItem } from "@earendil-works/pi-tui";
 
-import { setConfigGetter as setShikiConfig } from "./shiki.js";
-import { setConfigGetter as setRenderConfig } from "./render/index.js";
+import type { DiffRenderConfig } from "./render/index.js";
 import { DiffComponent } from "./diff-component.js";
 import type { DiffBg, DiffColors } from "./ansi/index.js";
-import { resetDiffColors } from "./ansi/index.js";
 import { installWriteTool, installEditTool } from "./tools/index.js";
 import { diag } from "./log.js";
 import { reportPiSupport } from "./pi-support.js";
@@ -27,12 +25,10 @@ export type { DiffBg, DiffColors } from "./ansi/index.js";
 // Config
 // ---------------------------------------------------------------------------
 
-export interface DiffConfig {
-	diffTheme: string;
-	diffSplitMinWidth: number;
-	diffSplitMinCodeWidth: number;
-	diffSplitWrapCheck?: boolean;
-}
+// The shape lives in the render layer (`render/shared.ts`), which is what
+// actually consumes it — aliased here so the public name survives and the shape
+// has exactly one declaration.
+export type DiffConfig = DiffRenderConfig;
 
 const DEFAULT_DIFF_CONFIG: DiffConfig = {
 	diffTheme: "github-dark",
@@ -41,15 +37,11 @@ const DEFAULT_DIFF_CONFIG: DiffConfig = {
 	diffSplitWrapCheck: true,
 };
 
-let _readConfig: () => DiffConfig = () => DEFAULT_DIFF_CONFIG;
-function getConfig(): DiffConfig { return _readConfig(); }
-
 // ---------------------------------------------------------------------------
 // Settings
 // ---------------------------------------------------------------------------
 
-export function getDiffSettingsItems(overrideConfig?: DiffConfig): SettingItem[] {
-	const config = overrideConfig ?? getConfig();
+export function getDiffSettingsItems(config: DiffConfig): SettingItem[] {
 	return [
 		{
 			id: "diffTheme",
@@ -117,8 +109,10 @@ try {
  * builds a fresh extension and hands registration a new handle. A module-wide
  * flag would then install for the first session only, and every session after
  * it would get pi's native `edit`/`write` rows and none of the result details
- * the rows read. The theme and config readers are per-session, so those are
- * refreshed on every call.
+ * the rows read. The config reader is not module state: it is handed to the
+ * installers and captured by the rows they register, so a second call on an
+ * already-installed handle is a no-op and cannot re-point the first session's
+ * rows at another session's config (#163).
  */
 const _installedExtensions = new WeakSet<object>();
 
@@ -135,15 +129,6 @@ export function registerDiffTools(
 	// runs again on every session_start.
 	reportPiSupport("diff", "1.2.0");
 
-	_readConfig = readConfig;
-
-	// Reset theme-derived colors so they are re-derived from the current theme
-	resetDiffColors();
-
-	// Wire config getters into submodules
-	setShikiConfig(() => getConfig());
-	setRenderConfig(() => getConfig());
-
 	// Already installed on this extension: re-registering would stack a duplicate
 	// resolver and handler set. A different handle is a different extension, so
 	// it installs even when this module instance is a reused one.
@@ -168,8 +153,8 @@ export function registerDiffTools(
 	// The rows are chosen by pi's renderer resolution, and the result details
 	// each row reads arrive through `tool_result` (ADR 0029). Neither registers a
 	// tool, so pi's own `edit` and `write` stay in place.
-	installEditTool(pi, cwd, home);
-	installWriteTool(pi, cwd, home, _TextComponent);
+	installEditTool(pi, cwd, home, readConfig);
+	installWriteTool(pi, cwd, home, _TextComponent, readConfig);
 	_installedExtensions.add(pi);
 }
 

package/src/module-state.test.ts

@@ -0,0 +1,91 @@
+/**
+ * Module-state shape pin for `packages/diff` (issue #163).
+ *
+ * `packages/core/src/session-state-discipline.test.ts` is the cross-package
+ * guard, but it is INTRA-FILE: it follows a session handler's body and the
+ * functions that body calls in the same file, so it was satisfied here by
+ * assigning `_readConfig` one line away from the handler that wrote it. This
+ * file asserts the SOURCE SHAPE instead, so it cannot be satisfied by moving an
+ * assignment to another file or one line further down.
+ *
+ * What is banned: a module-scope `let`/`var` holding a config getter, a config
+ * value, or a theme key, and any exported `setConfigGetter` — the setter being
+ * the tell that the binding is re-pointed per session rather than owned by the
+ * process.
+ *
+ * What stays allowed, deliberately: `_TextComponent` (`index.ts` — loaded once
+ * at module evaluation, never re-pointed) and `_shikiReady` (`shiki.ts` — an
+ * honest "the Shiki warm-up has run" flag). Both are pinned below so this file
+ * cannot quietly become a blanket "no module state" rule.
+ */
+
+import { describe, it, expect } from "vitest";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SRC_ROOT = fileURLToPath(new URL("./", import.meta.url));
+
+/** Every non-test `.ts` file under `packages/diff/src`. */
+function sourceFiles(dir: string = SRC_ROOT): string[] {
+  const out: string[] = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...sourceFiles(full));
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".ts") || entry.name.endsWith(".test.ts")) continue;
+    out.push(full);
+  }
+  return out;
+}
+
+/** A module-scope binding holding config, a config reader, or a theme key. */
+const CONFIG_HOLDER = /^\s*(?:export\s+)?(?:let|var)\s+_?(?:getConfig|_readConfig|_lastThemeKey)\b/;
+
+/** The exported setter that re-points such a binding per session. */
+const CONFIG_SETTER = /^\s*export\s+(?:function|const)\s+setConfigGetter\b/;
+
+function violations(files: readonly string[]): string[] {
+  const found: string[] = [];
+  for (const file of files) {
+    const rel = relative(SRC_ROOT, file).replace(/\\/g, "/");
+    const lines = readFileSync(file, "utf8").split("\n");
+    lines.forEach((line, i) => {
+      if (CONFIG_HOLDER.test(line)) {
+        found.push(`${rel}:${i + 1} [config holder at module scope] ${line.trim()}`);
+      }
+      if (CONFIG_SETTER.test(line)) {
+        found.push(`${rel}:${i + 1} [per-session config setter exported] ${line.trim()}`);
+      }
+    });
+  }
+  return found;
+}
+
+describe("diff module state (#163)", () => {
+  it("scans a non-empty file set (so the guard cannot go vacuous)", () => {
+    const files = sourceFiles();
+    expect(files.length).toBeGreaterThan(5);
+    for (const file of files) expect(statSync(file).isFile()).toBe(true);
+    expect(files.map((f) => relative(SRC_ROOT, f).replace(/\\/g, "/"))).toContain("shiki.ts");
+  });
+
+  it("declares no module-scope config holder and exports no setConfigGetter", () => {
+    expect(violations(sourceFiles())).toEqual([]);
+  });
+
+  it("still allows the two honest process-wide bindings", () => {
+    const index = readFileSync(join(SRC_ROOT, "index.ts"), "utf8");
+    const shiki = readFileSync(join(SRC_ROOT, "shiki.ts"), "utf8");
+    expect(index).toMatch(/^let _TextComponent:/m);
+    expect(shiki).toMatch(/^let _shikiReady = false;$/m);
+  });
+
+  it("keeps shiki.ts free of any import from index.js or render/ (no cycle)", () => {
+    const shiki = readFileSync(join(SRC_ROOT, "shiki.ts"), "utf8");
+    expect(shiki).not.toMatch(/from\s+["']\.\/index\.js["']/);
+    expect(shiki).not.toMatch(/from\s+["']\.\/render\//);
+  });
+});

package/src/render/index.ts

@@ -7,8 +7,7 @@ export {
 	MAX_HL_CHARS,
 	WORD_DIFF_MIN_SIM,
 	DEFAULT_TERM_WIDTH,
-	getConfig,
-	setConfigGetter,
+	type DiffRenderConfig,
 	adaptiveWrapRows,
 	wrapAnsi,
 	shouldUseSplit,

package/src/render/shared.test.ts

@@ -1,9 +1,7 @@
-import { describe, it, expect, beforeEach } from "vitest";
+import { describe, it, expect } from "vitest";
 import { parseDiff } from "../core/diff.js";
 import {
 	shouldUseSplit,
-	setConfigGetter,
-	getConfig,
 	adaptiveWrapRows,
 	wrapAnsi,
 } from "./shared.js";
@@ -48,44 +46,41 @@ describe("wrapAnsi", () => {
 });
 
 describe("render shared / shouldUseSplit", () => {
-	beforeEach(() => {
-		setConfigGetter(() => ({
-			diffSplitMinWidth: 150,
-			diffSplitMinCodeWidth: 60,
-			diffSplitWrapCheck: true,
-		}));
-	});
+	// The config used to arrive through a module-scope getter; it is now a
+	// parameter, so each case passes the object it previously installed.
+	const cfg = {
+		diffTheme: "github-dark",
+		diffSplitMinWidth: 150,
+		diffSplitMinCodeWidth: 60,
+		diffSplitWrapCheck: true,
+	};
 
 	it("returns false for empty diff", () => {
 		const diff = parseDiff("", "");
-		expect(shouldUseSplit(diff, 200)).toBe(false);
+		expect(shouldUseSplit(diff, 200, cfg)).toBe(false);
 	});
 
 	it("returns false if terminal width < diffSplitMinWidth", () => {
 		const old = "const x = 1;\n";
 		const updated = "const x = 2;\n";
 		const diff = parseDiff(old, updated);
-		expect(shouldUseSplit(diff, 140)).toBe(false);
+		expect(shouldUseSplit(diff, 140, cfg)).toBe(false);
 	});
 
 	it("returns false if available code column width < diffSplitMinCodeWidth", () => {
-		setConfigGetter(() => ({
-			diffSplitMinWidth: 100,
-			diffSplitMinCodeWidth: 60,
-			diffSplitWrapCheck: true,
-		}));
+		const narrow = { ...cfg, diffSplitMinWidth: 100, diffSplitMinCodeWidth: 60 };
 		const old = "const x = 1;\n";
 		const updated = "const x = 2;\n";
 		const diff = parseDiff(old, updated);
 		// With tw=110, half=54, nw=2, gw=7, cw=47 < 60 -> false
-		expect(shouldUseSplit(diff, 110)).toBe(false);
+		expect(shouldUseSplit(diff, 110, narrow)).toBe(false);
 	});
 
 	it("returns true for normal short lines when terminal width and code width fit", () => {
 		const old = "const x = 1;\n";
 		const updated = "const x = 2;\n";
 		const diff = parseDiff(old, updated);
-		expect(shouldUseSplit(diff, 200)).toBe(true);
+		expect(shouldUseSplit(diff, 200, cfg)).toBe(true);
 	});
 
 	it("falls back to false when lines wrap and diffSplitWrapCheck is true", () => {
@@ -93,18 +88,14 @@ describe("render shared / shouldUseSplit", () => {
 		const longLineNew = "const longLine = '" + "b".repeat(150) + "';\n";
 		const diff = parseDiff(longLineOld, longLineNew);
 		// In a 200 col terminal, cw ~ 92, line length > 150, all lines wrap (ratio = 1.0 >= 0.2)
-		expect(shouldUseSplit(diff, 200)).toBe(false);
+		expect(shouldUseSplit(diff, 200, cfg)).toBe(false);
 	});
 
 	it("returns true when lines wrap but diffSplitWrapCheck is false", () => {
-		setConfigGetter(() => ({
-			diffSplitMinWidth: 150,
-			diffSplitMinCodeWidth: 60,
-			diffSplitWrapCheck: false,
-		}));
+		const noWrapCheck = { ...cfg, diffSplitWrapCheck: false };
 		const longLineOld = "const longLine = '" + "a".repeat(150) + "';\n";
 		const longLineNew = "const longLine = '" + "b".repeat(150) + "';\n";
 		const diff = parseDiff(longLineOld, longLineNew);
-		expect(shouldUseSplit(diff, 200)).toBe(true);
+		expect(shouldUseSplit(diff, 200, noWrapCheck)).toBe(true);
 	});
 });

package/src/render/shared.ts

@@ -24,25 +24,12 @@ export const DEFAULT_TERM_WIDTH = 200;
 // ---------------------------------------------------------------------------
 
 export interface DiffRenderConfig {
+	diffTheme: string;
 	diffSplitMinWidth: number;
 	diffSplitMinCodeWidth: number;
 	diffSplitWrapCheck?: boolean;
 }
 
-export function getConfig(): DiffRenderConfig {
-	return typeof _getConfig === "function" ? _getConfig() : DEFAULT_CONFIG;
-}
-
-const DEFAULT_CONFIG: DiffRenderConfig = {
-	diffSplitMinWidth: 150,
-	diffSplitMinCodeWidth: 60,
-	diffSplitWrapCheck: true,
-};
-let _getConfig: (() => DiffRenderConfig) | undefined;
-export function setConfigGetter(fn: () => DiffRenderConfig): void {
-	_getConfig = fn;
-}
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -109,9 +96,8 @@ export function wrapAnsi(s: string, w: number, maxRows = adaptiveWrapRows(w), fi
 	return rows;
 }
 
-export function shouldUseSplit(diff: ParsedDiff, tw: number, maxRows = MAX_PREVIEW_LINES): boolean {
+export function shouldUseSplit(diff: ParsedDiff, tw: number, cfg: DiffRenderConfig, maxRows = MAX_PREVIEW_LINES): boolean {
 	if (!diff.lines.length) return false;
-	const cfg = getConfig();
 	if (tw < cfg.diffSplitMinWidth) return false;
 
 	const nw = Math.max(2, String(Math.max(...diff.lines.map((l) => l.oldNum ?? l.newNum ?? 0), 0)).length);

package/src/render/split.ts

@@ -13,6 +13,7 @@ import {
 	MAX_RENDER_LINES,
 	WORD_DIFF_MIN_SIM,
 	DEFAULT_TERM_WIDTH,
+	type DiffRenderConfig,
 	adaptiveWrapRows,
 	wrapAnsi,
 	shouldUseSplit,
@@ -30,11 +31,12 @@ import { renderUnifiedLines } from "./unified.js";
 export async function renderSplit(
 	diff: ParsedDiff,
 	language: BundledLanguage | undefined,
+	cfg: DiffRenderConfig,
 	max = MAX_PREVIEW_LINES,
 	dc: DiffColors = DEFAULT_DIFF_COLORS,
 ): Promise<string> {
 	const width = process.stdout.columns ?? DEFAULT_TERM_WIDTH;
-	const lines = await renderSplitLines(diff, language, width, max, dc, DEFAULT_DIFF_BG);
+	const lines = await renderSplitLines(diff, language, width, cfg, max, dc, DEFAULT_DIFF_BG);
 	return lines.join("\n");
 }
 
@@ -42,6 +44,7 @@ export async function renderSplitLines(
 	diff: ParsedDiff,
 	language: BundledLanguage | undefined,
 	width: number,
+	cfg: DiffRenderConfig,
 	max = MAX_PREVIEW_LINES,
 	dc: DiffColors = DEFAULT_DIFF_COLORS,
 	dbg: DiffBg = DEFAULT_DIFF_BG,
@@ -49,7 +52,7 @@ export async function renderSplitLines(
 	const rst = dbg.rst;
 	const bgBase = dbg.bgBase;
 
-	if (!shouldUseSplit(diff, width, max)) return renderUnifiedLines(diff, language, width, max, dc, dbg);
+	if (!shouldUseSplit(diff, width, cfg, max)) return renderUnifiedLines(diff, language, width, cfg, max, dc, dbg);
 	if (!diff.lines.length) return [];
 
 	type Row = { left: DiffLine | null; right: DiffLine | null };
@@ -80,7 +83,7 @@ export async function renderSplitLines(
 		if (r.right && r.right.type !== "sep") rightSrc.push(r.right.content);
 	}
 	const [leftHL, rightHL] = canHL
-		? await Promise.all([hlBlock(leftSrc.join("\n"), language), hlBlock(rightSrc.join("\n"), language)])
+		? await Promise.all([hlBlock(leftSrc.join("\n"), language, cfg.diffTheme), hlBlock(rightSrc.join("\n"), language, cfg.diffTheme)])
 		: [leftSrc, rightSrc];
 
 	let lI = 0, rI = 0;

package/src/render/unified.ts

@@ -12,6 +12,7 @@ import {
 	MAX_RENDER_LINES,
 	WORD_DIFF_MIN_SIM,
 	DEFAULT_TERM_WIDTH,
+	type DiffRenderConfig,
 	adaptiveWrapRows,
 	wrapAnsi,
 } from "./shared.js";
@@ -27,11 +28,12 @@ import {
 export async function renderUnified(
 	diff: ParsedDiff,
 	language: BundledLanguage | undefined,
+	cfg: DiffRenderConfig,
 	max = MAX_RENDER_LINES,
 	dc: DiffColors = DEFAULT_DIFF_COLORS,
 ): Promise<string> {
 	const width = process.stdout.columns ?? DEFAULT_TERM_WIDTH;
-	const lines = await renderUnifiedLines(diff, language, width, max, dc, DEFAULT_DIFF_BG);
+	const lines = await renderUnifiedLines(diff, language, width, cfg, max, dc, DEFAULT_DIFF_BG);
 	return lines.join("\n");
 }
 
@@ -39,6 +41,7 @@ export async function renderUnifiedLines(
 	diff: ParsedDiff,
 	language: BundledLanguage | undefined,
 	width: number,
+	cfg: DiffRenderConfig,
 	max = MAX_RENDER_LINES,
 	dc: DiffColors = DEFAULT_DIFF_COLORS,
 	dbg: DiffBg = DEFAULT_DIFF_BG,
@@ -61,7 +64,7 @@ export async function renderUnifiedLines(
 		if (l.type === "ctx" || l.type === "add") newSrc.push(l.content);
 	}
 	const [oldHL, newHL] = canHL
-		? await Promise.all([hlBlock(oldSrc.join("\n"), language), hlBlock(newSrc.join("\n"), language)])
+		? await Promise.all([hlBlock(oldSrc.join("\n"), language, cfg.diffTheme), hlBlock(newSrc.join("\n"), language, cfg.diffTheme)])
 		: [oldSrc, newSrc];
 
 	let oI = 0, nI = 0, idx = 0;

package/src/shiki.test.ts

@@ -15,7 +15,7 @@ vi.mock("./ansi/index.js", () => ({
 
 // ── Imports ──────────────────────────────────────────────────────────────────
 
-import { lang, setConfigGetter } from "./shiki.js";
+import { lang } from "./shiki.js";
 
 // ── lang ─────────────────────────────────────────────────────────────────────
 
@@ -231,33 +231,21 @@ describe("lang", () => {
 	});
 });
 
-// ── setConfigGetter ──────────────────────────────────────────────────────────
+// ── hlBlock ──────────────────────────────────────────────────────────────────
 
-describe("setConfigGetter", () => {
-	it("changes the config getter", async () => {
-		// Import hlBlock to test config getter effect
+// The theme used to arrive through a module-scope config getter that these tests
+// re-pointed; `hlBlock` now takes it directly (#163), so the two cases that
+// exercised real highlighting survive as explicit-theme calls.
+describe("hlBlock", () => {
+	it("returns an array of lines for a highlighted block", async () => {
 		const { hlBlock } = await import("./shiki.js");
-
-		setConfigGetter(() => ({ diffTheme: "github-light" }));
-
-		// The config getter should now return the new theme
-		// We can't directly inspect _getConfig, but we can verify hlBlock
-		// doesn't throw and uses the new config
-		const result = await hlBlock("const x = 1;", "javascript");
+		const result = await hlBlock("const x = 1;", "javascript", "github-dark");
 		expect(Array.isArray(result)).toBe(true);
 	});
 
-	it("accepts custom theme", async () => {
-		setConfigGetter(() => ({ diffTheme: "nord" }));
-
+	it("highlights a second language under its own theme", async () => {
 		const { hlBlock } = await import("./shiki.js");
-		const result = await hlBlock("print('hello')", "python");
+		const result = await hlBlock("print('hello')", "python", "github-dark");
 		expect(Array.isArray(result)).toBe(true);
 	});
-
-	it("restores default behavior after setting", () => {
-		setConfigGetter(() => ({ diffTheme: "github-dark" }));
-		// Should not throw
-		expect(() => setConfigGetter(() => ({ diffTheme: "one-dark" }))).not.toThrow();
-	});
 });

package/src/shiki.ts

@@ -6,15 +6,6 @@ import type { BundledLanguage, BundledTheme } from "shiki";
 
 import { normalizeShikiContrast } from "./ansi/index.js";
 
-// ---------------------------------------------------------------------------
-// Config access
-// ---------------------------------------------------------------------------
-
-let _getConfig: () => { diffTheme: string } = () => ({ diffTheme: "github-dark" });
-export function setConfigGetter(fn: () => { diffTheme: string }): void {
-	_getConfig = fn;
-}
-
 // ---------------------------------------------------------------------------
 // Language detection
 // ---------------------------------------------------------------------------
@@ -43,10 +34,10 @@ const MAX_HL_CHARS = 80_000;
 const CACHE_LIMIT = 192;
 
 let _shikiReady = false;
-async function ensureShiki(): Promise<void> {
+async function ensureShiki(theme: string): Promise<void> {
 	if (_shikiReady) return;
 	_shikiReady = true;
-	codeToANSI("", "typescript", _getConfig().diffTheme as BundledTheme).catch(() => {});
+	codeToANSI("", "typescript", theme as BundledTheme).catch(() => {});
 }
 
 const _cache = new Map<string, string[]>();
@@ -63,13 +54,12 @@ function _touch(k: string, v: string[]): string[] {
 	return v;
 }
 
-export async function hlBlock(code: string, language: BundledLanguage | undefined): Promise<string[]> {
+export async function hlBlock(code: string, language: BundledLanguage | undefined, theme: string): Promise<string[]> {
 	if (!code) return [""];
 	if (!language || code.length > MAX_HL_CHARS) return code.split("\n");
 
-	await ensureShiki();
+	await ensureShiki(theme);
 
-	const theme = _getConfig().diffTheme;
 	const k = `${theme}\0${language}\0${code}`;
 	const hit = _cache.get(k);
 	if (hit) return _touch(k, hit); // Promote to most-recently-used

package/src/tools/edit.test.ts

@@ -14,6 +14,15 @@ import path from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { createEditTool } from "@earendil-works/pi-coding-agent";
 import { createEditRenderers, installEditTool } from "./edit.js";
+import type { DiffRenderConfig } from "../render/index.js";
+
+/** The config the rows read — now threaded per registration rather than held per module (#163). */
+const DIFF_TEST_CONFIG: DiffRenderConfig = {
+  diffTheme: "github-dark",
+  diffSplitMinWidth: 150,
+  diffSplitMinCodeWidth: 60,
+  diffSplitWrapCheck: true,
+};
 
 // `diff` is standalone and must not import `@pi-archimedes/core` (see
 // `src/pi-support.ts`), so the tests strip escape sequences themselves.
@@ -39,6 +48,7 @@ function captureTool(cwd: string, home: string) {
     } as unknown as ExtensionAPI,
     cwd,
     home,
+    () => DIFF_TEST_CONFIG,
   );
   return resolved;
 }
@@ -185,7 +195,7 @@ describe("edit row padding", () => {
   // The row draws its own shell (`renderShell: "self"`), so the inset is ours to
   // choose — but pi still tells the renderer how much tool output is padded
   // here, and that number is what the row must respect.
-  const renderers = createEditRenderers("/project", "/home");
+  const renderers = createEditRenderers("/project", "/home", () => DIFF_TEST_CONFIG);
   const callArgs = { path: "/project/src/a.ts", edits: [{ oldText: "x", newText: "y" }] };
 
   function padXFor(outputPad: number): number {

package/src/tools/edit.ts

@@ -7,7 +7,7 @@ import { parseDiff } from "../core/diff.js";
 import * as Ansi from "../ansi/index.js";
 import { themeCacheKey } from "../ansi/index.js";
 import { lang } from "../shiki.js";
-import { MAX_PREVIEW_LINES } from "../render/index.js";
+import { MAX_PREVIEW_LINES, type DiffRenderConfig } from "../render/index.js";
 import { DiffComponent } from "../diff-component.js";
 
 interface EditOperation { oldText: string; newText: string }
@@ -75,13 +75,17 @@ export function editResultDetails(event: {
 }
 
 /** The Archimedes `edit` renderers, closed over the paths they shorten against. */
-export function createEditRenderers(cwd: string, home: string): ToolRenderers {
+export function createEditRenderers(cwd: string, home: string, readConfig: () => DiffRenderConfig): ToolRenderers {
 	const sp = (p: string) => Ansi.shortPath(cwd, home, p);
 
 	return {
 		renderShell: "self",
 
 		renderCall(args: any, theme: any, ctx: any) {
+			// Resolved once per invocation, not per row: the reader belongs to the
+			// session that registered this row, so it is captured here rather than
+			// read back out of module state (#163).
+			const cfg = readConfig();
 			const fp = args?.path ?? args?.file_path ?? "";
 			const operations = getEditOperations(args);
 
@@ -126,7 +130,7 @@ export function createEditRenderers(cwd: string, home: string): ToolRenderers {
 				const diff = diffs[0];
 				if (diff) {
 					shell.addChild(new Spacer(1));
-					shell.addChild(new DiffComponent(diff, lg, theme, MAX_PREVIEW_LINES));
+					shell.addChild(new DiffComponent(diff, lg, theme, cfg, MAX_PREVIEW_LINES));
 				}
 			} else {
 				const maxShown = Math.min(operations.length, 3);
@@ -139,7 +143,7 @@ export function createEditRenderers(cwd: string, home: string): ToolRenderers {
 						theme.fg("muted", `Edit ${i + 1}/${operations.length}`),
 						0, 0,
 					));
-					shell.addChild(new DiffComponent(diff, lg, theme, previewLines));
+					shell.addChild(new DiffComponent(diff, lg, theme, cfg, previewLines));
 				}
 				const remainder = operations.length - maxShown;
 				if (remainder > 0) {
@@ -213,8 +217,8 @@ export function createEditRenderers(cwd: string, home: string): ToolRenderers {
  * handlers per extension, so calling it from `session_start` would stack a
  * duplicate on every `/reload`.
  */
-export function installEditTool(pi: ExtensionAPI, cwd: string, home: string): void {
-	const renderers = createEditRenderers(cwd, home);
+export function installEditTool(pi: ExtensionAPI, cwd: string, home: string, readConfig: () => DiffRenderConfig): void {
+	const renderers = createEditRenderers(cwd, home, readConfig);
 	pi.registerToolRenderer((toolName, next) =>
 		toolName === "edit" ? { ...next(), ...renderers } : next(),
 	);

package/src/tools/register.test.ts

@@ -18,6 +18,19 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { installEditTool } from "./edit.js";
 import { installWriteTool } from "./write.js";
+import type { DiffRenderConfig } from "../render/index.js";
+
+/**
+ * The config reader both installers now take as their last argument (#163): it
+ * is captured by the rows each registration builds, never parked in module
+ * state where a second session could re-point it.
+ */
+const cfg = (): DiffRenderConfig => ({
+  diffTheme: "github-dark",
+  diffSplitMinWidth: 150,
+  diffSplitMinCodeWidth: 60,
+  diffSplitWrapCheck: true,
+});
 
 /** A `pi` handle that records what was registered. */
 function fakePi() {
@@ -69,7 +82,7 @@ const emit = (
 describe("edit registration", () => {
   it("registers no tool and resolves only `edit`", () => {
     const { pi, renderers, registered } = fakePi();
-    installEditTool(pi, "/work", "/home");
+    installEditTool(pi, "/work", "/home", cfg);
 
     expect(registered).toHaveLength(0);
     expect(renderers).toHaveLength(1);
@@ -79,7 +92,7 @@ describe("edit registration", () => {
 
   it("keeps the built-in's own renderShell while replacing the renderers", () => {
     const { pi, renderers } = fakePi();
-    installEditTool(pi, "/work", "/home");
+    installEditTool(pi, "/work", "/home", cfg);
 
     const { result } = resolve(renderers[0], "edit");
     expect(typeof result.renderCall).toBe("function");
@@ -92,7 +105,7 @@ describe("edit registration", () => {
     const { dir, file, done } = makeWorkspace("one\ntwo\nthree\n");
     try {
       const { pi, handlers } = fakePi();
-      installEditTool(pi, dir, dir);
+      installEditTool(pi, dir, dir, cfg);
       writeFileSync(file, "one\n2\nthree\n");
 
       const out = emit(handlers, "tool_result", {
@@ -117,7 +130,7 @@ describe("edit registration", () => {
     const { dir, file, done } = makeWorkspace();
     try {
       const { pi, handlers } = fakePi();
-      installEditTool(pi, dir, dir);
+      installEditTool(pi, dir, dir, cfg);
 
       const out = emit(handlers, "tool_result", {
         type: "tool_result",
@@ -146,7 +159,7 @@ describe("edit registration", () => {
     const { dir, file, done } = makeWorkspace();
     try {
       const { pi, handlers } = fakePi();
-      installEditTool(pi, dir, dir);
+      installEditTool(pi, dir, dir, cfg);
 
       const out = emit(handlers, "tool_result", {
         type: "tool_result",
@@ -168,7 +181,7 @@ describe("edit registration", () => {
 describe("write registration", () => {
   it("registers no tool and resolves only `write`", () => {
     const { pi, renderers, registered } = fakePi();
-    installWriteTool(pi, "/work", "/home", Text as any);
+    installWriteTool(pi, "/work", "/home", Text as any, cfg);
 
     expect(registered).toHaveLength(0);
     expect(resolve(renderers[0], "write").result?.renderShell).toBe("default");
@@ -179,7 +192,7 @@ describe("write registration", () => {
     const { dir, file, done } = makeWorkspace("one\ntwo\n");
     try {
       const { pi, handlers } = fakePi();
-      installWriteTool(pi, dir, dir, Text as any);
+      installWriteTool(pi, dir, dir, Text as any, cfg);
 
       emit(handlers, "tool_call", {
         type: "tool_call",
@@ -210,7 +223,7 @@ describe("write registration", () => {
     try {
       const fresh = path.join(dir, "fresh.txt");
       const { pi, handlers } = fakePi();
-      installWriteTool(pi, dir, dir, Text as any);
+      installWriteTool(pi, dir, dir, Text as any, cfg);
 
       emit(handlers, "tool_call", {
         type: "tool_call",
@@ -239,7 +252,7 @@ describe("write registration", () => {
     const { dir, file, done } = makeWorkspace("same\n");
     try {
       const { pi, handlers } = fakePi();
-      installWriteTool(pi, dir, dir, Text as any);
+      installWriteTool(pi, dir, dir, Text as any, cfg);
 
       emit(handlers, "tool_call", {
         type: "tool_call",

package/src/tools/write.test.ts

@@ -15,6 +15,15 @@ import path from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { installWriteTool } from "./write.js";
+import type { DiffRenderConfig } from "../render/index.js";
+
+/** The config the rows read — now threaded per registration rather than held per module (#163). */
+const DIFF_TEST_CONFIG: DiffRenderConfig = {
+  diffTheme: "github-dark",
+  diffSplitMinWidth: 150,
+  diffSplitMinCodeWidth: 60,
+  diffSplitWrapCheck: true,
+};
 
 // `diff` is standalone and must not import `@pi-archimedes/core` (see
 // `src/pi-support.ts`), so the tests strip escape sequences themselves.
@@ -41,6 +50,7 @@ function captureTool(cwd: string, home: string) {
     cwd,
     home,
     Text as any,
+    () => DIFF_TEST_CONFIG,
   );
   return resolved;
 }

package/src/tools/write.ts

@@ -8,7 +8,7 @@ import * as Ansi from "../ansi/index.js";
 import { themeCacheKey } from "../ansi/index.js";
 import { lang, hlBlock } from "../shiki.js";
 import { DiffComponent } from "../diff-component.js";
-import { MAX_RENDER_LINES } from "../render/index.js";
+import { MAX_RENDER_LINES, type DiffRenderConfig } from "../render/index.js";
 
 /**
  * The content a `write` call displaces, read while the call is still about to
@@ -67,11 +67,14 @@ export function createWriteRenderers(
 	cwd: string,
 	home: string,
 	TextComponent: new (text?: string, paddingX?: number, paddingY?: number) => Component,
+	readConfig: () => DiffRenderConfig,
 ): ToolRenderers {
 	const sp = (p: string) => Ansi.shortPath(cwd, home, p);
 
 	return {
 		renderCall(args: any, theme: any, ctx: any) {
+			// Once per invocation — see the same note in `edit.ts` (#163).
+			const cfg = readConfig();
 			const fp = args?.path ?? args?.file_path ?? "";
 			const isNew = !fp || !existsSync(fp);
 			const label = isNew ? "create" : "write";
@@ -90,7 +93,7 @@ export function createWriteRenderers(
 					ctx.state._previewKey = previewKey;
 					ctx.state._previewText = hdr;
 					const lg = lang(fp);
-					hlBlock(args.content, lg)
+					hlBlock(args.content, lg, cfg.diffTheme)
 						.then((lines: string[]) => {
 							if (ctx.state._previewKey !== previewKey) return;
 							const maxShow = ctx.expanded ? lines.length : 16;
@@ -112,6 +115,7 @@ export function createWriteRenderers(
 		},
 
 		renderResult(result: any, _opt: any, theme: any, ctx: any) {
+			const cfg = readConfig();
 			const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
 			if (ctx.isError) {
 				const e = result.content
@@ -125,7 +129,7 @@ export function createWriteRenderers(
 			if (d?._type === "diff") {
 				const comp = ctx.lastComponent instanceof DiffComponent
 					? ctx.lastComponent
-					: new DiffComponent(d.diff, d.language, theme, MAX_RENDER_LINES);
+					: new DiffComponent(d.diff, d.language, theme, cfg, MAX_RENDER_LINES);
 				return comp;
 			}
 			if (d?._type === "noChange") {
@@ -140,7 +144,7 @@ export function createWriteRenderers(
 					ctx.state._nft = `  ${theme.fg("success", `✓ new file (${lineCount} lines)`)}`;
 					const lg = lang(fp);
 					if (rawContent) {
-						hlBlock(rawContent, lg)
+						hlBlock(rawContent, lg, cfg.diffTheme)
 							.then((hlLines: string[]) => {
 								if (ctx.state._nfk !== pk) return;
 								const maxShow = ctx.expanded ? hlLines.length : 12;
@@ -178,8 +182,9 @@ export function installWriteTool(
 	cwd: string,
 	home: string,
 	TextComponent: new (text?: string, paddingX?: number, paddingY?: number) => Component,
+	readConfig: () => DiffRenderConfig,
 ): void {
-	const renderers = createWriteRenderers(cwd, home, TextComponent);
+	const renderers = createWriteRenderers(cwd, home, TextComponent, readConfig);
 	pi.registerToolRenderer((toolName, next) =>
 		toolName === "write" ? { ...next(), ...renderers } : next(),
 	);