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

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",
@@ -1864,6 +1904,37 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"github.cache.enabled": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "tools",
+			label: "GitHub view cache",
+			description: "Cache rendered issue/PR view output in ~/.omp/cache/github-cache.db so repeated reads are free",
+		},
+	},
+
+	"github.cache.softTtlSec": {
+		type: "number",
+		default: 300,
+		ui: {
+			tab: "tools",
+			label: "GitHub cache soft TTL (seconds)",
+			description: "Within this window, cached issue/PR view rows are returned directly. Default 5 minutes.",
+		},
+	},
+
+	"github.cache.hardTtlSec": {
+		type: "number",
+		default: 604800,
+		ui: {
+			tab: "tools",
+			label: "GitHub cache hard TTL (seconds)",
+			description:
+				"Past soft TTL but within hard TTL, the tool returns the cached row and refreshes it in the background. Past hard TTL, the row is dropped. Default 7 days.",
+		},
+	},
+
 	"web_search.enabled": {
 		type: "boolean",
 		default: true,
@@ -2064,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/index.ts

@@ -145,13 +145,15 @@ async function executeApplyPatchPerFile(
 			const result = await run(batchRequest);
 			const details = result.details;
 			perFileResults.push({
-				path,
+				path: details?.path ?? path,
 				diff: details?.diff ?? "",
 				firstChangedLine: details?.firstChangedLine,
 				diagnostics: details?.diagnostics,
 				op: details?.op,
 				move: details?.move,
 				meta: details?.meta,
+				oldText: details?.oldText,
+				newText: details?.newText,
 			});
 			const text = result.content?.find(c => c.type === "text")?.text ?? "";
 			if (text) contentTexts.push(text);
@@ -205,6 +207,11 @@ async function executeSinglePathEntries(
 	const diffTexts: string[] = [];
 	let firstChangedLine: number | undefined;
 	let errorCount = 0;
+	let metadataPath: string | undefined;
+	let hasFirstOldText = false;
+	let firstOldText: string | undefined;
+	let hasLastNewText = false;
+	let lastNewText: string | undefined;
 
 	for (let i = 0; i < runs.length; i++) {
 		const isLast = i === runs.length - 1;
@@ -217,6 +224,17 @@ async function executeSinglePathEntries(
 			const details = result.details;
 			if (details?.diff) diffTexts.push(details.diff);
 			firstChangedLine ??= details?.firstChangedLine;
+			if (details?.path) {
+				metadataPath ??= details.path;
+			}
+			if (details && "oldText" in details && !hasFirstOldText) {
+				firstOldText = details.oldText;
+				hasFirstOldText = true;
+			}
+			if (details && "newText" in details) {
+				lastNewText = details.newText;
+				hasLastNewText = true;
+			}
 			const text = result.content?.find(c => c.type === "text")?.text ?? "";
 			if (text) contentTexts.push(text);
 		} catch (err) {
@@ -242,6 +260,9 @@ async function executeSinglePathEntries(
 		details: {
 			diff: diffTexts.join("\n"),
 			firstChangedLine,
+			path: metadataPath ?? path,
+			...(hasFirstOldText ? { oldText: firstOldText } : {}),
+			...(hasLastNewText ? { newText: lastNewText } : {}),
 		},
 		// Any per-entry failure marks the aggregate result as an error so the
 		// renderer takes the error branch instead of falling through to the

package/src/edit/modes/patch.ts

@@ -1772,15 +1772,25 @@ export async function executePatchSingle(
 		.diagnostics(mergedDiagnostics?.summary ?? "", mergedDiagnostics?.messages ?? [])
 		.get();
 
+	const oldText = result.change.type !== "create" ? result.change.oldContent : undefined;
+	const newText = result.change.type !== "delete" ? result.change.newContent : undefined;
+
 	return {
 		content: [{ type: "text", text: resultText }],
 		details: {
 			diff: diffResult.diff,
+			// When the patch moves the file, anchor the diff to the destination
+			// path. ACP `ToolCallContent.diff.path` comes from this field, and
+			// clients use it to open or focus the file post-change; pointing at
+			// the (now-deleted) source navigates to nothing.
+			path: result.change.newPath ?? resolvedPath,
 			firstChangedLine: diffResult.firstChangedLine,
 			diagnostics: mergedDiagnostics,
 			op,
 			move: effectiveRename,
 			meta,
+			oldText,
+			newText,
 		},
 	};
 }

package/src/edit/modes/replace.ts

@@ -1094,9 +1094,12 @@ export async function executeReplaceSingle(
 		content: [{ type: "text", text: resultText }],
 		details: {
 			diff: diffResult.diff,
+			path: absolutePath,
 			firstChangedLine: diffResult.firstChangedLine,
 			diagnostics,
 			meta,
+			oldText: rawContent,
+			newText: finalContent,
 		},
 	};
 }

package/src/edit/renderer.ts

@@ -55,6 +55,10 @@ export interface EditToolPerFileResult {
 	 * Set when the underlying error carries a `displayMessage` (e.g. {@link HashlineMismatchError}). */
 	displayErrorText?: string;
 	meta?: OutputMeta;
+	/** Source-of-truth content before the edit; `undefined` for create operations. */
+	oldText?: string;
+	/** Source-of-truth content after the edit; `undefined` for delete operations. */
+	newText?: string;
 }
 
 export interface EditToolDetails {
@@ -72,6 +76,12 @@ export interface EditToolDetails {
 	meta?: OutputMeta;
 	/** Per-file results (multi-file edits) */
 	perFileResults?: EditToolPerFileResult[];
+	/** Absolute file path for single-file edit results. Required by ACP diff metadata consumers. */
+	path?: string;
+	/** Source-of-truth content before the edit; `undefined` for create operations. */
+	oldText?: string;
+	/** Source-of-truth content after the edit; `undefined` for delete operations. */
+	newText?: string;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -330,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/context-manager.ts

@@ -17,7 +17,7 @@ import type {
 	WorkerOutbound,
 } from "./worker-protocol";
 
-export { rewriteStaticImports } from "./shared/rewrite-imports";
+export { rewriteImports, wrapCode } from "./shared/rewrite-imports";
 export type { JsDisplayOutput } from "./worker-protocol";
 
 export interface VmRunState {

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);