@oh-my-pi/pi-coding-agent 16.1.9 → 16.1.11

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.1.9",
+	"version": "16.1.11",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -48,17 +48,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.1.9",
-		"@oh-my-pi/omp-stats": "16.1.9",
-		"@oh-my-pi/pi-agent-core": "16.1.9",
-		"@oh-my-pi/pi-ai": "16.1.9",
-		"@oh-my-pi/pi-catalog": "16.1.9",
-		"@oh-my-pi/pi-mnemopi": "16.1.9",
-		"@oh-my-pi/pi-natives": "16.1.9",
-		"@oh-my-pi/pi-tui": "16.1.9",
-		"@oh-my-pi/pi-utils": "16.1.9",
-		"@oh-my-pi/pi-wire": "16.1.9",
-		"@oh-my-pi/snapcompact": "16.1.9",
+		"@oh-my-pi/hashline": "16.1.11",
+		"@oh-my-pi/omp-stats": "16.1.11",
+		"@oh-my-pi/pi-agent-core": "16.1.11",
+		"@oh-my-pi/pi-ai": "16.1.11",
+		"@oh-my-pi/pi-catalog": "16.1.11",
+		"@oh-my-pi/pi-mnemopi": "16.1.11",
+		"@oh-my-pi/pi-natives": "16.1.11",
+		"@oh-my-pi/pi-tui": "16.1.11",
+		"@oh-my-pi/pi-utils": "16.1.11",
+		"@oh-my-pi/pi-wire": "16.1.11",
+		"@oh-my-pi/snapcompact": "16.1.11",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/scripts/generate-aria-snapshot.ts

@@ -0,0 +1,134 @@
+#!/usr/bin/env bun
+/**
+ * Regenerates the committed browser asset
+ *
+ *   src/tools/browser/aria/aria-snapshot.bundle.txt   ← bundled CJS module
+ *
+ * by fetching Playwright's injected ARIA-snapshot sources (pinned to
+ * PLAYWRIGHT_TAG), wrapping them with a small entry, and bundling — all in a
+ * throwaway temp dir. Only the bundle is committed; the upstream sources are NOT
+ * vendored into the repo (no shipping both source + generated copies). This is a
+ * dev-time, network-bound step, exactly like `generate-models`.
+ *
+ * The tab worker imports the `.txt` with `{ type: "text" }`, wraps it in a
+ * `new Function` worker-side, and runs it via puppeteer's CDP evaluate (it
+ * installs nothing on `window`). The committed output means binary and source
+ * installs need no network or build step at runtime.
+ *
+ * Usage: bun scripts/generate-aria-snapshot.ts
+ */
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+
+const PLAYWRIGHT_TAG = "v1.61.0";
+const RAW_BASE = `https://raw.githubusercontent.com/microsoft/playwright/${PLAYWRIGHT_TAG}/packages`;
+
+const OUTPUT = path.join(import.meta.dir, "..", "src", "tools", "browser", "aria", "aria-snapshot.bundle.txt");
+
+// Upstream source path -> temp path (relative to the temp root).
+const VENDOR_FILES: Array<[string, string]> = [
+	["injected/src/ariaSnapshot.ts", "injected/ariaSnapshot.ts"],
+	["injected/src/roleUtils.ts", "injected/roleUtils.ts"],
+	["injected/src/domUtils.ts", "injected/domUtils.ts"],
+	["isomorphic/ariaSnapshot.ts", "isomorphic/ariaSnapshot.ts"],
+	["isomorphic/stringUtils.ts", "isomorphic/stringUtils.ts"],
+	["isomorphic/cssTokenizer.ts", "isomorphic/cssTokenizer.ts"],
+	["isomorphic/yaml.ts", "isomorphic/yaml.ts"],
+];
+
+// Entry wrapping the upstream modules. Always runs Playwright's `ai` mode so every
+// node carries a `[ref=eN]` id; matched nodes get an `_ariaRef` expando. Existing
+// expandos are cleared first so the fresh module's counter renumbers from e1
+// deterministically (refs are valid until the next snapshot). Installs nothing on
+// `window`.
+const ENTRY_SOURCE = `
+import { generateAriaTree, renderAriaTree } from "./injected/ariaSnapshot";
+
+export interface AriaSnapshotRequest {
+	depth?: number;
+	boxes?: boolean;
+}
+
+function walkElements(fn: (el: Element) => void): void {
+	const walk = (root: { querySelectorAll(s: string): ArrayLike<Element> }): void => {
+		for (const el of Array.from(root.querySelectorAll("*"))) {
+			fn(el);
+			const shadow = (el as Element & { shadowRoot?: { querySelectorAll(s: string): ArrayLike<Element> } | null }).shadowRoot;
+			if (shadow) walk(shadow);
+		}
+	};
+	walk(document as unknown as { querySelectorAll(s: string): ArrayLike<Element> });
+}
+type RefElement = Element & { _ariaRef?: { role: string; name: string; ref: string } };
+
+export function ariaSnapshot(root: Element | null, request: AriaSnapshotRequest = {}): string {
+	walkElements(el => {
+		if ((el as RefElement)._ariaRef) delete (el as RefElement)._ariaRef;
+	});
+	const target = root ?? document.body ?? document.documentElement;
+	const options = { mode: "ai", depth: request.depth, boxes: request.boxes } as const;
+	const tree = generateAriaTree(target, options);
+	return renderAriaTree(tree, options).text;
+}
+
+export function resolveAriaRef(ref: string): Element | null {
+	let found: Element | null = null;
+	walkElements(el => {
+		if (!found && (el as RefElement)._ariaRef?.ref === ref) found = el;
+	});
+	return found;
+}
+`;
+
+async function main(): Promise<void> {
+	const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "omp-aria-"));
+	try {
+		// Fetch pinned upstream sources into the temp dir.
+		for (const [src, dst] of VENDOR_FILES) {
+			const url = `${RAW_BASE}/${src}`;
+			const res = await fetch(url);
+			if (!res.ok) throw new Error(`Failed to fetch ${url}: ${res.status}`);
+			await Bun.write(path.join(tmp, dst), await res.text());
+		}
+		const entry = path.join(tmp, "entry.ts");
+		await Bun.write(entry, ENTRY_SOURCE);
+
+		// The injected sources import isomorphic modules via the `@isomorphic/*`
+		// alias and the `yaml` package (type-only). Resolve the alias to the fetched
+		// copies and stub `yaml` (only referenced from erased `import type`).
+		const aliasPlugin: Bun.BunPlugin = {
+			name: "aria-vendor-alias",
+			setup(build) {
+				build.onResolve({ filter: /^@isomorphic\// }, args => ({
+					path: path.join(tmp, "isomorphic", `${args.path.slice("@isomorphic/".length)}.ts`),
+				}));
+				build.onResolve({ filter: /^yaml$/ }, () => ({ path: "yaml", namespace: "aria-yaml-stub" }));
+				build.onLoad({ filter: /.*/, namespace: "aria-yaml-stub" }, () => ({
+					contents: "export {};",
+					loader: "ts",
+				}));
+			},
+		};
+
+		const result = await Bun.build({
+			entrypoints: [entry],
+			target: "browser",
+			format: "cjs",
+			minify: true,
+			plugins: [aliasPlugin],
+		});
+		if (!result.success) {
+			for (const log of result.logs) console.error(log);
+			throw new Error("aria snapshot bundle failed");
+		}
+		const code = await result.outputs[0].text();
+		const header = `// @generated by scripts/generate-aria-snapshot.ts from Playwright ${PLAYWRIGHT_TAG}\n// Bundled from Playwright's injected ARIA-snapshot sources (Apache-2.0, (c) Microsoft).\n// Do not edit by hand. Regenerate with: bun scripts/generate-aria-snapshot.ts\n`;
+		await Bun.write(OUTPUT, header + code);
+		console.log(`bundled ${path.relative(process.cwd(), OUTPUT)} (${code.length}b)`);
+	} finally {
+		await fs.rm(tmp, { recursive: true, force: true });
+	}
+}
+
+await main();

package/scripts/generate-share-viewer.ts

@@ -19,8 +19,10 @@ if (!outPath) {
 }
 
 const loaderJs = await Bun.file(new URL("../src/export/html/share-loader.js", import.meta.url).pathname).text();
-// Pin a built-in theme: the viewer is a public artifact, not a per-user export.
-const themeVars = await generateThemeVars("dark");
+// Pin the omp brand palette (collab-web pink/purple identity) — the viewer is
+// a public artifact matching the live my.omp.sh client, not a per-user export
+// that should mirror the host's terminal theme.
+const themeVars = await generateThemeVars("web");
 
 const html = getTemplate()
 	.replace("<theme-vars/>", () => `<style>:root { ${themeVars} }</style>`)

package/src/autoresearch/git.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI } from "../extensibility/extensions";
 import * as git from "../utils/git";
+import * as jj from "../utils/jj";
 import { normalizePathSpec } from "./helpers";
 
 const AUTORESEARCH_BRANCH_PREFIX = "autoresearch/";
@@ -37,6 +38,17 @@ export async function ensureAutoresearchBranch(
 	workDir: string,
 	goal: string | null,
 ): Promise<EnsureAutoresearchBranchResult> {
+	// Pure-jj check runs first so a jj workspace nested under an unrelated
+	// outer Git checkout is rejected at its own root rather than silently
+	// creating `autoresearch/*` branches and commits in the surrounding Git
+	// tree behind jj's back.
+	if (await jj.isPureJjRepo(workDir)) {
+		return {
+			ok: false,
+			error: "Autoresearch needs a Git checkout for branch isolation and baseline commits, but this workspace is pure Jujutsu (`.jj/` without a colocated `.git/`). Run `jj git init --colocate` to add a Git checkout before starting autoresearch.",
+		};
+	}
+
 	const repoRoot = await git.repo.root(workDir);
 	if (!repoRoot) {
 		return {

package/src/config/settings-schema.ts

@@ -967,6 +967,18 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	includeWorkspaceTree: {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "model",
+			group: "Prompt",
+			label: "Include Workspace Tree",
+			description:
+				"Render the workspace directory tree in the system prompt. WARNING: This can bust prompt caching across sessions when files are modified.",
+		},
+	},
+
 	personality: {
 		type: "enum",
 		values: ["default", "friendly", "pragmatic", "none"] as const,

package/src/discovery/opencode.ts

@@ -91,15 +91,55 @@ async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFil
 /** OpenCode MCP server config (from opencode.json "mcp" key) */
 interface OpenCodeMCPConfig {
 	type?: "local" | "remote";
-	command?: string;
+	command?: string | string[];
 	args?: string[];
 	env?: Record<string, string>;
+	environment?: Record<string, string>;
 	url?: string;
 	headers?: Record<string, string>;
 	enabled?: boolean;
 	timeout?: number;
 }
 
+function stringArray(value: unknown): string[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	for (const item of value) {
+		if (typeof item !== "string") return undefined;
+	}
+	return value;
+}
+
+function stringRecord(value: unknown): Record<string, string> | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+
+	const record: Record<string, string> = {};
+	for (const [key, item] of Object.entries(value)) {
+		if (typeof item !== "string") return undefined;
+		record[key] = item;
+	}
+	return record;
+}
+
+function normalizeCommand(
+	commandValue: string | string[] | undefined,
+	argsValue: unknown,
+): { command: string | undefined; args: string[] | undefined } {
+	const configuredArgs = stringArray(argsValue);
+	if (Array.isArray(commandValue)) {
+		const [command, ...commandArgs] = commandValue;
+		const args = configuredArgs ? [...commandArgs, ...configuredArgs] : commandArgs;
+		return {
+			command: typeof command === "string" ? command : undefined,
+			args: args.length > 0 ? args : undefined,
+		};
+	}
+
+	return {
+		command: typeof commandValue === "string" ? commandValue : undefined,
+		args: configuredArgs && configuredArgs.length > 0 ? configuredArgs : undefined,
+	};
+}
+
 async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
 	const items: MCPServer[] = [];
 	const warnings: string[] = [];
@@ -161,11 +201,14 @@ function extractMCPServers(
 			transport = "stdio";
 		}
 
+		const command = normalizeCommand(serverConfig.command, serverConfig.args);
+		const env = stringRecord(serverConfig.environment) ?? stringRecord(serverConfig.env);
+
 		items.push({
 			name,
-			command: serverConfig.command,
-			args: Array.isArray(serverConfig.args) ? (serverConfig.args as string[]) : undefined,
-			env: serverConfig.env && typeof serverConfig.env === "object" ? serverConfig.env : undefined,
+			command: command.command,
+			args: command.args,
+			env,
 			url: typeof serverConfig.url === "string" ? serverConfig.url : undefined,
 			headers: serverConfig.headers && typeof serverConfig.headers === "object" ? serverConfig.headers : undefined,
 			enabled: serverConfig.enabled,

package/src/edit/hashline/filesystem.ts

@@ -20,6 +20,7 @@ import { Filesystem, NotFoundError, type WriteResult } from "@oh-my-pi/hashline"
 import { isEnoent } from "@oh-my-pi/pi-utils";
 import type { FileDiagnosticsResult, WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
 import type { ToolSession } from "../../tools";
+import { routeWriteThroughBridge } from "../../tools/acp-bridge";
 import { assertEditableFileContent } from "../../tools/auto-generated-guard";
 import { invalidateFsScanAfterWrite } from "../../tools/fs-cache-invalidation";
 import { enforcePlanModeWrite, resolvePlanPath } from "../../tools/plan-mode-guard";
@@ -110,6 +111,13 @@ export class HashlineFilesystem extends Filesystem {
 		await this.preflightWrite(relativePath);
 		const absolutePath = this.resolveAbsolute(relativePath);
 		const finalContent = await serializeEditFileText(absolutePath, relativePath, content);
+
+		// Route through ACP bridge when available; skips internal artifacts.
+		if (await routeWriteThroughBridge(this.session, relativePath, absolutePath, finalContent)) {
+			this.#diagnosticsByPath.set(relativePath, undefined);
+			return { text: finalContent };
+		}
+
 		const diagnostics = await this.#writethrough(
 			absolutePath,
 			finalContent,

package/src/edit/modes/patch.ts

@@ -17,6 +17,7 @@ import {
 	type WritethroughDeferredHandle,
 } from "../../lsp";
 import type { ToolSession } from "../../tools";
+import { routeWriteThroughBridge } from "../../tools/acp-bridge";
 import { assertEditableFile } from "../../tools/auto-generated-guard";
 import {
 	invalidateFsScanAfterDelete,
@@ -1663,6 +1664,8 @@ class LspFileSystem implements FileSystem {
 	#fileCache: Record<string, Bun.BunFile> = {};
 
 	constructor(
+		private readonly session: ToolSession,
+		private readonly requestedPath: string,
 		private readonly writethrough: WritethroughCallback,
 		private readonly signal?: AbortSignal,
 		private readonly batchRequest?: LspBatchRequest,
@@ -1692,8 +1695,14 @@ class LspFileSystem implements FileSystem {
 	}
 
 	async write(path: string, content: string): Promise<void> {
-		const file = this.#getFile(path);
 		const finalContent = await serializeEditFileText(path, path, content);
+
+		// Route through ACP bridge when available; skips internal artifacts and local:// paths.
+		if (await routeWriteThroughBridge(this.session, this.requestedPath, path, finalContent)) {
+			return;
+		}
+
+		const file = this.#getFile(path);
 		const deferredForPath = this.deferredForPath;
 		const result = await this.writethrough(
 			path,
@@ -1785,7 +1794,14 @@ export async function executePatchSingle(
 	}
 
 	const input: PatchInput = { path: resolvedPath, op, rename: resolvedRename, diff };
-	const patchFileSystem = new LspFileSystem(writethrough, signal, batchRequest, beginDeferredDiagnosticsForPath);
+	const patchFileSystem = new LspFileSystem(
+		session,
+		path, // original user-provided path for bridge guard (may be local://, vault://, etc.)
+		writethrough,
+		signal,
+		batchRequest,
+		beginDeferredDiagnosticsForPath,
+	);
 	const result = await applyPatch(input, {
 		cwd: session.cwd,
 		fs: patchFileSystem,

package/src/edit/modes/replace.ts

@@ -6,8 +6,9 @@
  */
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { type } from "arktype";
-import type { WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
+import type { FileDiagnosticsResult, WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
 import type { ToolSession } from "../../tools";
+import { routeWriteThroughBridge } from "../../tools/acp-bridge";
 import { invalidateFsScanAfterWrite } from "../../tools/fs-cache-invalidation";
 import { outputMeta } from "../../tools/output-meta";
 import { enforcePlanModeWrite, resolvePlanPath } from "../../tools/plan-mode-guard";
@@ -1098,15 +1099,17 @@ export async function executeReplaceSingle(
 		path,
 		bom + restoreLineEndings(result.content, originalEnding),
 	);
-	const diagnostics = await writethrough(
-		absolutePath,
-		finalContent,
-		signal,
-		Bun.file(absolutePath),
-		batchRequest,
-		dst => (dst === absolutePath ? beginDeferredDiagnosticsForPath(absolutePath) : undefined),
-	);
-	invalidateFsScanAfterWrite(absolutePath);
+
+	// Route through ACP bridge when available; skips internal artifacts.
+	let diagnostics: FileDiagnosticsResult | undefined;
+	if (await routeWriteThroughBridge(session, path, absolutePath, finalContent)) {
+		// bridge handled the write; diagnostics not available via writethrough
+	} else {
+		diagnostics = await writethrough(absolutePath, finalContent, signal, Bun.file(absolutePath), batchRequest, dst =>
+			dst === absolutePath ? beginDeferredDiagnosticsForPath(absolutePath) : undefined,
+		);
+		invalidateFsScanAfterWrite(absolutePath);
+	}
 
 	const diffResult = generateDiffString(normalizedContent, result.content, undefined, { path });
 	const resultText =

package/src/edit/streaming.ts

@@ -85,12 +85,12 @@ export interface EditStreamingStrategy<Args = unknown> {
 
 /**
  * Given an edits array parsed from partial JSON, drop the last entry when the
- * corresponding object in `partialJson` does not yet end with a closed `}`.
+ * corresponding object in `partialJson` has not yet closed with `}`.
  *
- * This guards against `partial-json` silently coercing truncated tails like
- * `"write":nu` / `"write":nul` into `{ write: null }`, which would make the
- * last entry render a spurious null-write error until the value finishes
- * streaming.
+ * The streaming parser materializes a trailing edit object from the fields seen
+ * so far before its closing `}` arrives, so an unfinished last entry can render
+ * as a (partial) edit mid-stream. Dropping it until the object closes keeps the
+ * preview from showing an incomplete edit.
  */
 export function dropIncompleteLastEdit<T>(edits: readonly T[], partialJson: string | undefined, listKey: string): T[] {
 	if (!Array.isArray(edits) || edits.length === 0) return [...(edits ?? [])];

package/src/export/html/index.ts

@@ -12,6 +12,7 @@ import templateJs from "./template.js" with { type: "text" };
 // Pre-built React tool renderers: built by `bun --cwd=packages/collab-web run build:tool-views`,
 // run automatically by root `prepare` on install and by `prepack` at publish.
 import toolViewsJs from "./tool-views.generated.js" with { type: "text" };
+import { webExportThemeVars } from "./web-palette";
 
 let cachedTemplate: string | undefined;
 
@@ -36,6 +37,19 @@ export function getTemplate(): string {
 
 export interface ExportOptions {
 	outputPath?: string;
+	/**
+	 * Which color palette the export ships with.
+	 * - `"web"` (default) — the omp brand identity (collab-web pink/purple),
+	 *   so public HTML exports and the `/s/<id>` share viewer match the live
+	 *   `my.omp.sh` client. See `web-palette.ts`.
+	 * - `"theme"` — derive from `themeName` (or the active TUI theme), preserving
+	 *   the pre-15.12 behavior where an export mirrored the user's terminal.
+	 */
+	palette?: "web" | "theme";
+	/**
+	 * TUI theme to derive colors from when `palette: "theme"`. Ignored for the
+	 * default `"web"` palette. Resolves to the active TUI theme when omitted.
+	 */
 	themeName?: string;
 	/** Embed subagent session transcripts found next to the session file (default true). */
 	includeSubSessions?: boolean;
@@ -101,12 +115,38 @@ function deriveExportColors(baseColor: string): { pageBg: string; cardBg: string
 	};
 }
 
-/** Generate CSS custom properties for theme. Exported for the share-viewer build script. */
-export async function generateThemeVars(themeName?: string): Promise<string> {
+/**
+ * Generate CSS custom properties for the export `:root`.
+ *
+ * Two call shapes:
+ *   • `generateThemeVars("web" | "theme", themeName?)` — explicit palette.
+ *     `"web"` (the default for public artifacts) returns the fixed omp brand
+ *     palette from `web-palette.ts` — collab-web pink/purple identity, shared
+ *     with the live `my.omp.sh` client, so exports and the share viewer render
+ *     identically to it. `"theme"` derives from the TUI theme via
+ *     `getResolvedThemeColors(themeName)` plus the three
+ *     `export.{pageBg,cardBg,infoBg}` surface overrides.
+ *   • `generateThemeVars(themeName)` — legacy single-arg form: derive from the
+ *     named TUI theme. Kept so existing callers (and the theme-islight test)
+ *     keep working; equivalent to `generateThemeVars("theme", themeName)`.
+ *
+ * Exported for the share-viewer build script.
+ */
+export async function generateThemeVars(
+	palette: "web" | "theme" | (string & {}) = "web",
+	themeName?: string,
+): Promise<string> {
+	// Legacy single-arg form: `generateThemeVars("my-theme")` — the first arg
+	// is a theme name, not a palette. Route it to the themed path.
+	if (palette !== "web" && palette !== "theme") {
+		return generateThemeVars("theme", palette);
+	}
+	if (palette === "web") return webExportThemeVars();
+
 	const colors = await getResolvedThemeColors(themeName);
 	const lines: string[] = [];
-	for (const [key, value] of Object.entries(colors)) {
-		lines.push(`--${key}: ${value};`);
+	for (const key in colors) {
+		lines.push(`--${key}: ${colors[key]};`);
 	}
 
 	const themeExport = await getThemeExportColors(themeName);
@@ -200,8 +240,8 @@ async function collectSubSessionsFromDir(
 }
 
 /** Generate HTML from bundled template with runtime substitutions. */
-async function generateHtml(sessionData: SessionData, themeName?: string): Promise<string> {
-	const themeVars = await generateThemeVars(themeName);
+async function generateHtml(sessionData: SessionData, palette: "web" | "theme", themeName?: string): Promise<string> {
+	const themeVars = await generateThemeVars(palette, themeName);
 	const sessionDataBase64 = Buffer.from(JSON.stringify(sessionData)).toBase64();
 
 	// Use function replacements so `$'`, `$&`, `$$`, `$n`, etc. in the
@@ -229,7 +269,8 @@ export async function exportSessionToHtml(
 		if (Object.keys(subSessions).length > 0) sessionData.subSessions = subSessions;
 	}
 
-	const html = await generateHtml(sessionData, opts.themeName);
+	const palette = opts.palette ?? (opts.themeName ? "theme" : "web");
+	const html = await generateHtml(sessionData, palette, opts.themeName);
 	const outputPath = opts.outputPath || `${APP_NAME}-session-${path.basename(sessionFile, ".jsonl")}.html`;
 
 	await Bun.write(outputPath, html);
@@ -258,7 +299,8 @@ export async function exportFromFile(inputPath: string, options?: ExportOptions
 		if (Object.keys(subSessions).length > 0) sessionData.subSessions = subSessions;
 	}
 
-	const html = await generateHtml(sessionData, opts.themeName);
+	const palette = opts.palette ?? (opts.themeName ? "theme" : "web");
+	const html = await generateHtml(sessionData, palette, opts.themeName);
 	const outputPath = opts.outputPath || `${APP_NAME}-session-${path.basename(inputPath, ".jsonl")}.html`;
 
 	await Bun.write(outputPath, html);