@oh-my-pi/pi-coding-agent 15.0.0 → 15.0.1

package/src/config/config-file.ts

@@ -0,0 +1,210 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getAgentDir, isEnoent, logger } from "@oh-my-pi/pi-utils";
+import type { TSchema } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+import type { ErrorObject } from "ajv";
+import { JSONC, YAML } from "bun";
+
+function migrateJsonToYml(jsonPath: string, ymlPath: string) {
+	try {
+		if (fs.existsSync(ymlPath)) return;
+		if (!fs.existsSync(jsonPath)) return;
+
+		const content = fs.readFileSync(jsonPath, "utf-8");
+		const parsed = JSON.parse(content);
+		if (!parsed) {
+			logger.warn("migrateJsonToYml: invalid json structure", { path: jsonPath });
+			return;
+		}
+		fs.writeFileSync(ymlPath, YAML.stringify(parsed, null, 2));
+	} catch (error) {
+		logger.warn("migrateJsonToYml: migration failed", { error: String(error) });
+	}
+}
+
+export interface IConfigFile<T> {
+	readonly id: string;
+	readonly schema: TSchema;
+	path?(): string;
+	load(): T | null;
+	invalidate?(): void;
+}
+
+export class ConfigError extends Error {
+	readonly #message: string;
+	constructor(
+		public readonly id: string,
+		public readonly schemaErrors: ErrorObject[] | null | undefined,
+		public readonly other?: { err: unknown; stage: string },
+	) {
+		let messages: string[] | undefined;
+		let cause: Error | undefined;
+		let klass: string;
+
+		if (schemaErrors) {
+			klass = "Schema";
+			messages = schemaErrors.map(e => `${e.instancePath || "root"}: ${e.message}`);
+		} else if (other) {
+			klass = other.stage;
+			if (other.err instanceof Error) {
+				messages = [other.err.message];
+				cause = other.err;
+			} else {
+				messages = [String(other.err)];
+			}
+		} else {
+			klass = "Unknown";
+		}
+
+		const title = `Failed to load config file ${id}, ${klass} error:`;
+		let message: string;
+		switch (messages?.length ?? 0) {
+			case 0:
+				message = title.slice(0, -1);
+				break;
+			case 1:
+				message = `${title} ${messages![0]}`;
+				break;
+			default:
+				message = `${title}\n${messages!.map(m => `  - ${m}`).join("\n")}`;
+				break;
+		}
+
+		super(message, { cause });
+		this.name = "LoadError";
+		this.#message = message;
+	}
+
+	get message(): string {
+		return this.#message;
+	}
+
+	toString(): string {
+		return this.message;
+	}
+}
+
+export type LoadStatus = "ok" | "error" | "not-found";
+
+export type LoadResult<T> =
+	| { value?: null; error: ConfigError; status: "error" }
+	| { value: T; error?: undefined; status: "ok" }
+	| { value?: null; error?: unknown; status: "not-found" };
+
+export class ConfigFile<T> implements IConfigFile<T> {
+	readonly #basePath: string;
+	#cache?: LoadResult<T>;
+	#auxValidate?: (value: T) => void;
+
+	constructor(
+		readonly id: string,
+		readonly schema: TSchema,
+		configPath: string = path.join(getAgentDir(), `${id}.yml`),
+	) {
+		this.#basePath = configPath;
+		if (configPath.endsWith(".yml")) {
+			const jsonPath = `${configPath.slice(0, -4)}.json`;
+			migrateJsonToYml(jsonPath, configPath);
+		} else if (configPath.endsWith(".yaml")) {
+			const jsonPath = `${configPath.slice(0, -5)}.json`;
+			migrateJsonToYml(jsonPath, configPath);
+		} else if (configPath.endsWith(".json") || configPath.endsWith(".jsonc")) {
+			// JSON configs are still supported without migration.
+		} else {
+			throw new Error(`Invalid config file path: ${configPath}`);
+		}
+	}
+
+	relocate(configPath?: string): ConfigFile<T> {
+		if (!configPath || configPath === this.#basePath) return this;
+		const result = new ConfigFile<T>(this.id, this.schema, configPath);
+		result.#auxValidate = this.#auxValidate;
+		return result;
+	}
+
+	getMtimeMs(): number | null {
+		try {
+			return fs.statSync(this.path()).mtimeMs;
+		} catch (err) {
+			if (isEnoent(err)) return null;
+			throw err;
+		}
+	}
+
+	withValidation(name: string, validate: (value: T) => void): this {
+		const prev = this.#auxValidate;
+		this.#auxValidate = (value: T) => {
+			prev?.(value);
+			try {
+				validate(value);
+			} catch (error) {
+				throw new ConfigError(this.id, undefined, { err: error, stage: `Validate(${name})` });
+			}
+		};
+		return this;
+	}
+
+	createDefault(): T {
+		return Value.Default(this.schema, [], undefined) as T;
+	}
+
+	#storeCache(result: LoadResult<T>): LoadResult<T> {
+		this.#cache = result;
+		return result;
+	}
+
+	tryLoad(): LoadResult<T> {
+		if (this.#cache) return this.#cache;
+
+		try {
+			const content = fs.readFileSync(this.path(), "utf-8").trim();
+
+			let parsed: unknown;
+			if (this.#basePath.endsWith(".json") || this.#basePath.endsWith(".jsonc")) {
+				parsed = JSONC.parse(content);
+			} else if (this.#basePath.endsWith(".yml") || this.#basePath.endsWith(".yaml")) {
+				parsed = YAML.parse(content);
+			} else {
+				throw new Error(`Invalid config file path: ${this.#basePath}`);
+			}
+
+			if (!Value.Check(this.schema, parsed)) {
+				const schemaErrors: ErrorObject[] = [];
+				for (const err of Value.Errors(this.schema, parsed)) {
+					schemaErrors.push({ instancePath: err.path, message: err.message } as ErrorObject);
+					if (schemaErrors.length >= 50) break;
+				}
+				const error = new ConfigError(this.id, schemaErrors);
+				logger.warn("Failed to parse config file", { path: this.path(), error });
+				return this.#storeCache({ error, status: "error" });
+			}
+			return this.#storeCache({ value: parsed as T, status: "ok" });
+		} catch (error) {
+			if (isEnoent(error)) {
+				return this.#storeCache({ status: "not-found" });
+			}
+			logger.warn("Failed to parse config file", { path: this.path(), error });
+			return this.#storeCache({
+				error: new ConfigError(this.id, undefined, { err: error, stage: "Unexpected" }),
+				status: "error",
+			});
+		}
+	}
+
+	load(): T | null {
+		return this.tryLoad().value ?? null;
+	}
+
+	loadOrDefault(): T {
+		return this.tryLoad().value ?? this.createDefault();
+	}
+
+	path(): string {
+		return this.#basePath;
+	}
+
+	invalidate() {
+		this.#cache = undefined;
+	}
+}

package/src/config/model-equivalence.ts

@@ -72,15 +72,12 @@ const TRAILING_MARKER_SUFFIXES: readonly string[] = (() => {
 })();
 const WRAPPER_PREFIXES = ["duo-chat-"] as const;
 
-let __referenceDataCache: CanonicalReferenceData | undefined;
+let referenceDataCache: CanonicalReferenceData | undefined;
 const EMPTY_COMPILED_EQUIVALENCE: CompiledEquivalenceConfig = {
 	overrides: new Map<string, string>(),
 	exclude: new Set<string>(),
 };
-const __resolutionCache: WeakMap<
-	CompiledEquivalenceConfig,
-	WeakMap<Model<Api>, ResolvedCanonicalModel>
-> = new WeakMap();
+const resolutionCache: WeakMap<CompiledEquivalenceConfig, WeakMap<Model<Api>, ResolvedCanonicalModel>> = new WeakMap();
 const FAMILY_EXTRACTION_PATTERNS = [
 	/(?:^|[/:._-])((?:claude|gemini|gpt|grok|glm|qwen|minimax|kimi|deepseek|llama|gemma|nova|mistral|ministral|pixtral|codestral|devstral|magistral|ernie|doubao|seed|aion|olmo|molmo|nemotron|palmyra|command|codex|coder|o[1345])[-a-z0-9.]+)(?::|$)/i,
 	/(?:^|[/:._-])((?:claude|gemini|gpt|grok|glm|qwen|minimax|kimi|deepseek|llama|gemma|nova|mistral|ministral|pixtral|codestral|devstral|magistral|ernie|doubao|seed|aion|olmo|molmo|nemotron|palmyra|command|codex|coder|o[1345])[-a-z0-9.]+(?:[-_/][a-z0-9.]+)*)(?::|$)/i,
@@ -98,8 +95,8 @@ function shouldReplaceReference(existing: Model<Api> | undefined, candidate: Mod
 }
 
 function createCanonicalReferenceData(): CanonicalReferenceData {
-	if (__referenceDataCache) {
-		return __referenceDataCache;
+	if (referenceDataCache) {
+		return referenceDataCache;
 	}
 	const references = new Map<string, Model<Api>>();
 	for (const provider of getBundledProviders()) {
@@ -112,11 +109,11 @@ function createCanonicalReferenceData(): CanonicalReferenceData {
 		}
 	}
 	const officialIds = new Set(references.keys());
-	__referenceDataCache = {
+	referenceDataCache = {
 		references: Object.freeze(references) as Map<string, Model<Api>>,
 		officialIds: Object.freeze(officialIds) as Set<string>,
 	};
-	return __referenceDataCache;
+	return referenceDataCache;
 }
 
 function normalizeSelectorKey(selector: string): string {
@@ -668,10 +665,10 @@ export function buildCanonicalModelIndex(
 	const byId = new Map<string, CanonicalModelRecord>();
 	const bySelector = new Map<string, string>();
 
-	let modelCache = __resolutionCache.get(compiledEquivalence);
+	let modelCache = resolutionCache.get(compiledEquivalence);
 	if (!modelCache) {
 		modelCache = new WeakMap<Model<Api>, ResolvedCanonicalModel>();
-		__resolutionCache.set(compiledEquivalence, modelCache);
+		resolutionCache.set(compiledEquivalence, modelCache);
 	}
 
 	for (const model of models) {

package/src/config/model-registry.ts

@@ -18,6 +18,8 @@ import {
 	registerCustomApi,
 	type SimpleStreamOptions,
 	type ThinkingConfig,
+	UNK_CONTEXT_WINDOW,
+	UNK_MAX_TOKENS,
 	unregisterCustomApis,
 } from "@oh-my-pi/pi-ai";
 
@@ -29,10 +31,10 @@ import { registerOAuthProvider, unregisterOAuthProviders } from "@oh-my-pi/pi-ai
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/utils/oauth/types";
 import { isRecord, logger } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import { type ConfigError, ConfigFile } from "../config";
 import { parseModelString, resolveProviderModelReference } from "../config/model-resolver";
 import { isValidThemeColor, type ThemeColor } from "../modes/theme/theme";
 import type { AuthStorage, OAuthCredential } from "../session/auth-storage";
+import { type ConfigError, ConfigFile } from "./config-file";
 import {
 	buildCanonicalModelIndex,
 	type CanonicalModelIndex,
@@ -1053,7 +1055,16 @@ export class ModelRegistry {
 			const key = `${replacementModel.provider}\u0000${replacementModel.id}`;
 			const existingIndex = indexByKey.get(key);
 			if (existingIndex !== undefined) {
-				merged[existingIndex] = replacementModel;
+				const existing = merged[existingIndex];
+				merged[existingIndex] = {
+					...replacementModel,
+					contextWindow:
+						replacementModel.contextWindow === UNK_CONTEXT_WINDOW
+							? existing.contextWindow
+							: replacementModel.contextWindow,
+					maxTokens:
+						replacementModel.maxTokens === UNK_MAX_TOKENS ? existing.maxTokens : replacementModel.maxTokens,
+				};
 			} else {
 				merged.push(replacementModel);
 				indexByKey.set(key, merged.length - 1);

package/src/config/model-resolver.ts

@@ -12,10 +12,10 @@ import {
 	type Model,
 	modelsAreEqual,
 } from "@oh-my-pi/pi-ai";
+import { fuzzyMatch } from "@oh-my-pi/pi-tui";
 import chalk from "chalk";
 import MODEL_PRIO from "../priority.json" with { type: "json" };
 import { parseThinkingLevel, resolveThinkingLevelForModel } from "../thinking";
-import { fuzzyMatch } from "../utils/fuzzy";
 import { isAuthenticated, kNoAuth, MODEL_ROLE_IDS, type ModelRegistry, type ModelRole } from "./model-registry";
 import type { Settings } from "./settings";
 
@@ -607,9 +607,6 @@ export function resolveModelRoleValue(
 		return { model: undefined, thinkingLevel: undefined, explicitThinkingLevel: false, warning: undefined };
 	}
 
-	const lastColonIndex = normalized.lastIndexOf(":");
-	const _thinkingSelector =
-		lastColonIndex > PREFIX_MODEL_ROLE.length ? parseThinkingLevel(normalized.slice(lastColonIndex + 1)) : undefined;
 	const effectivePatterns = resolveConfiguredRolePattern(normalized, options?.settings);
 	if (!effectivePatterns || effectivePatterns.length === 0) {
 		return { model: undefined, thinkingLevel: undefined, explicitThinkingLevel: false, warning: undefined };

package/src/config/settings-schema.ts

@@ -460,6 +460,46 @@ export const SETTINGS_SCHEMA = {
 			],
 		},
 	},
+	"tools.artifactHeadBytes": {
+		type: "number",
+		default: 20,
+		ui: {
+			tab: "tools",
+			label: "Artifact head size (KB)",
+			description:
+				"Amount of head content kept inline alongside the tail when output spills to artifact (middle elision). 0 disables — keep tail only.",
+			options: [
+				{ value: "0", label: "0 KB", description: "Disabled; tail-only truncation" },
+				{ value: "1", label: "1 KB", description: "~250 tokens" },
+				{ value: "2.5", label: "2.5 KB", description: "~625 tokens" },
+				{ value: "5", label: "5 KB", description: "~1.25K tokens" },
+				{ value: "10", label: "10 KB", description: "~2.5K tokens" },
+				{ value: "20", label: "20 KB", description: "Default; ~5K tokens" },
+				{ value: "50", label: "50 KB", description: "~12.5K tokens" },
+				{ value: "100", label: "100 KB", description: "~25K tokens" },
+				{ value: "200", label: "200 KB", description: "~50K tokens" },
+			],
+		},
+	},
+	"tools.outputMaxColumns": {
+		type: "number",
+		default: 768,
+		ui: {
+			tab: "tools",
+			label: "Output column cap",
+			description:
+				"Per-line byte cap for streaming tool outputs (bash, ssh, python, js eval) and `read`. Lines wider than this are ellipsis-truncated; remaining bytes up to the next newline are dropped. 0 disables.",
+			options: [
+				{ value: "0", label: "Off", description: "No per-line cap" },
+				{ value: "256", label: "256", description: "Tight" },
+				{ value: "512", label: "512" },
+				{ value: "768", label: "768", description: "Default" },
+				{ value: "1024", label: "1024" },
+				{ value: "2048", label: "2048" },
+				{ value: "4096", label: "4096", description: "Loose" },
+			],
+		},
+	},
 	"tools.artifactTailLines": {
 		type: "number",
 		default: 500,
@@ -1498,7 +1538,7 @@ export const SETTINGS_SCHEMA = {
 
 	"read.defaultLimit": {
 		type: "number",
-		default: 500,
+		default: 300,
 		ui: {
 			tab: "editing",
 			label: "Default Read Limit",
@@ -2095,6 +2135,36 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"goal.enabled": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "tasks",
+			label: "Goal Mode",
+			description: "Enable per-session goal mode and the hidden goal tool",
+		},
+	},
+
+	"goal.statusInFooter": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "tasks",
+			label: "Goal Status In Footer",
+			description: "Show token budget alongside the goal indicator in the status line",
+		},
+	},
+
+	"goal.continuationModes": {
+		type: "array",
+		default: ["interactive"],
+		ui: {
+			tab: "tasks",
+			label: "Goal Continuation Modes",
+			description: "Run modes where active goals may auto-continue between turns",
+		},
+	},
+
 	// Delegation
 	"task.isolation.mode": {
 		type: "enum",

package/src/config/settings.ts

@@ -850,7 +850,7 @@ export function isSettingsInitialized(): boolean {
  * Reset the global singleton for testing.
  * @internal
  */
-export function _resetSettingsForTest(): void {
+export function resetSettingsForTest(): void {
 	globalInstance = null;
 	globalInstancePromise = null;
 }

package/src/config.ts

@@ -1,20 +1,11 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import {
-	CONFIG_DIR_NAME,
-	getAgentDir,
-	getConfigAgentDirName,
-	getProjectDir,
-	isEnoent,
-	logger,
-} from "@oh-my-pi/pi-utils";
-import type { TSchema } from "@sinclair/typebox";
-import { Value } from "@sinclair/typebox/value";
-import type { ErrorObject } from "ajv";
-import { JSONC, YAML } from "bun";
+import { CONFIG_DIR_NAME, getConfigAgentDirName, getProjectDir } from "@oh-my-pi/pi-utils";
 import { expandTilde } from "./tools/path-utils";
 
+export * from "./config/config-file";
+
 const priorityList = [
 	{ dir: CONFIG_DIR_NAME, globalAgentDir: getConfigAgentDirName },
 	{ dir: ".claude" },
@@ -53,213 +44,6 @@ export function getChangelogPath(): string {
 	return path.resolve(path.join(getPackageDir(), "CHANGELOG.md"));
 }
 
-// =============================================================================
-// User Config Paths (~/.omp/agent/*)
-// =============================================================================
-
-function migrateJsonToYml(jsonPath: string, ymlPath: string) {
-	try {
-		if (fs.existsSync(ymlPath)) return;
-		if (!fs.existsSync(jsonPath)) return;
-
-		const content = fs.readFileSync(jsonPath, "utf-8");
-		const parsed = JSON.parse(content);
-		if (!parsed) {
-			logger.warn("migrateJsonToYml: invalid json structure", { path: jsonPath });
-			return;
-		}
-		fs.writeFileSync(ymlPath, YAML.stringify(parsed, null, 2));
-	} catch (error) {
-		logger.warn("migrateJsonToYml: migration failed", { error: String(error) });
-	}
-}
-
-export interface IConfigFile<T> {
-	readonly id: string;
-	readonly schema: TSchema;
-	path?(): string;
-	load(): T | null;
-	invalidate?(): void;
-}
-
-export class ConfigError extends Error {
-	readonly #message: string;
-	constructor(
-		public readonly id: string,
-		public readonly schemaErrors: ErrorObject[] | null | undefined,
-		public readonly other?: { err: unknown; stage: string },
-	) {
-		let messages: string[] | undefined;
-		let cause: any | undefined;
-		let klass: string;
-
-		if (schemaErrors) {
-			klass = "Schema";
-			messages = schemaErrors.map(e => `${e.instancePath || "root"}: ${e.message}`);
-		} else if (other) {
-			klass = other.stage;
-			if (other.err instanceof Error) {
-				messages = [other.err.message];
-				cause = other.err;
-			} else {
-				messages = [String(other.err)];
-			}
-		} else {
-			klass = "Unknown";
-		}
-
-		const title = `Failed to load config file ${id}, ${klass} error:`;
-		let message: string;
-		switch (messages?.length ?? 0) {
-			case 0:
-				message = title.slice(0, -1);
-				break;
-			case 1:
-				message = `${title} ${messages![0]}`;
-				break;
-			default:
-				message = `${title}\n${messages!.map(m => `  - ${m}`).join("\n")}`;
-				break;
-		}
-
-		super(message, { cause });
-		this.name = "LoadError";
-		this.#message = message;
-	}
-
-	get message(): string {
-		return this.#message;
-	}
-
-	toString(): string {
-		return this.message;
-	}
-}
-
-export type LoadStatus = "ok" | "error" | "not-found";
-
-export type LoadResult<T> =
-	| { value?: null; error: ConfigError; status: "error" }
-	| { value: T; error?: undefined; status: "ok" }
-	| { value?: null; error?: unknown; status: "not-found" };
-
-export class ConfigFile<T> implements IConfigFile<T> {
-	readonly #basePath: string;
-	#cache?: LoadResult<T>;
-	#auxValidate?: (value: T) => void;
-
-	constructor(
-		readonly id: string,
-		readonly schema: TSchema,
-		configPath: string = path.join(getAgentDir(), `${id}.yml`),
-	) {
-		this.#basePath = configPath;
-		if (configPath.endsWith(".yml")) {
-			const jsonPath = `${configPath.slice(0, -4)}.json`;
-			migrateJsonToYml(jsonPath, configPath);
-		} else if (configPath.endsWith(".yaml")) {
-			const jsonPath = `${configPath.slice(0, -5)}.json`;
-			migrateJsonToYml(jsonPath, configPath);
-		} else if (configPath.endsWith(".json") || configPath.endsWith(".jsonc")) {
-			// JSON configs are still supported without migration.
-		} else {
-			throw new Error(`Invalid config file path: ${configPath}`);
-		}
-	}
-
-	relocate(path?: string): ConfigFile<T> {
-		if (!path || path === this.#basePath) return this;
-		const result = new ConfigFile<T>(this.id, this.schema, path);
-		result.#auxValidate = this.#auxValidate;
-		return result;
-	}
-
-	getMtimeMs(): number | null {
-		try {
-			return fs.statSync(this.path()).mtimeMs;
-		} catch (err) {
-			if (isEnoent(err)) return null;
-			throw err;
-		}
-	}
-
-	withValidation(name: string, validate: (value: T) => void): this {
-		const prev = this.#auxValidate;
-		this.#auxValidate = (value: T) => {
-			prev?.(value);
-			try {
-				validate(value);
-			} catch (error) {
-				throw new ConfigError(this.id, undefined, { err: error, stage: `Validate(${name})` });
-			}
-		};
-		return this;
-	}
-
-	createDefault() {
-		return Value.Default(this.schema, [], undefined) as T;
-	}
-
-	#storeCache(result: LoadResult<T>): LoadResult<T> {
-		this.#cache = result;
-		return result;
-	}
-
-	tryLoad(): LoadResult<T> {
-		if (this.#cache) return this.#cache;
-
-		try {
-			const content = fs.readFileSync(this.path(), "utf-8").trim();
-
-			let parsed: unknown;
-			if (this.#basePath.endsWith(".json") || this.#basePath.endsWith(".jsonc")) {
-				parsed = JSONC.parse(content);
-			} else if (this.#basePath.endsWith(".yml") || this.#basePath.endsWith(".yaml")) {
-				parsed = YAML.parse(content);
-			} else {
-				throw new Error(`Invalid config file path: ${this.#basePath}`);
-			}
-
-			if (!Value.Check(this.schema, parsed)) {
-				const schemaErrors: ErrorObject[] = [];
-				for (const err of Value.Errors(this.schema, parsed)) {
-					schemaErrors.push({ instancePath: err.path, message: err.message } as ErrorObject);
-					if (schemaErrors.length >= 50) break;
-				}
-				const error = new ConfigError(this.id, schemaErrors);
-				logger.warn("Failed to parse config file", { path: this.path(), error });
-				return this.#storeCache({ error, status: "error" });
-			}
-			return this.#storeCache({ value: parsed as T, status: "ok" });
-		} catch (error) {
-			if (isEnoent(error)) {
-				return this.#storeCache({ status: "not-found" });
-			}
-			logger.warn("Failed to parse config file", { path: this.path(), error });
-			return this.#storeCache({
-				error: new ConfigError(this.id, undefined, { err: error, stage: "Unexpected" }),
-				status: "error",
-			});
-		}
-	}
-
-	load(): T | null {
-		return this.tryLoad().value ?? null;
-	}
-
-	loadOrDefault(): T {
-		return this.tryLoad().value ?? this.createDefault();
-	}
-
-	path(): string {
-		return this.#basePath;
-	}
-
-	invalidate() {
-		this.#cache = undefined;
-	}
-}
-
 // =============================================================================
 // Multi-Config Directory Helpers
 // =============================================================================

package/src/edit/renderer.ts

@@ -340,7 +340,13 @@ function normalizeHashlineInputPreviewPath(rawPath: string): string {
 
 function parseHashlineInputPreviewHeader(line: string): string | null {
 	if (!line.startsWith(HL_INPUT_HEADER_PREFIX)) return null;
-	const body = line.slice(HL_INPUT_HEADER_PREFIX.length).trim();
+	// The real parser (`parseHashlineHeaderLine` in `hashline/input.ts`) strips
+	// every leading "@" before resolving the path so canonical "@@ PATH" headers
+	// (and stray "@ PATH" / "@@@ PATH" runs) all route to the same file. Mirror
+	// that here so the renderer doesn't surface a literal "@ " in the title.
+	let prefixEnd = 0;
+	while (prefixEnd < line.length && line[prefixEnd] === HL_INPUT_HEADER_PREFIX) prefixEnd++;
+	const body = line.slice(prefixEnd).trim();
 	const previewPath = normalizeHashlineInputPreviewPath(body);
 	return previewPath.length > 0 ? previewPath : null;
 }

package/src/eval/js/executor.ts

@@ -1,5 +1,6 @@
 import { DEFAULT_MAX_BYTES, OutputSink } from "../../session/streaming-output";
 import type { ToolSession } from "../../tools";
+import { resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "../../tools/output-meta";
 import { executeInVmContext, type JsDisplayOutput } from "./context-manager";
 
 export interface JsExecutorOptions {
@@ -49,6 +50,8 @@ export async function executeJs(code: string, options: JsExecutorOptions): Promi
 		artifactPath: options.artifactPath,
 		artifactId: options.artifactId,
 		spillThreshold: DEFAULT_MAX_BYTES,
+		headBytes: resolveOutputSinkHeadBytes(options.session.settings),
+		maxColumns: resolveOutputMaxColumns(options.session.settings),
 		onChunk: chunk => options.onChunk?.(chunk),
 	});
 	const timeoutMs = getExecutionTimeoutMs(options);