@oh-my-pi/pi-coding-agent 14.5.14 → 14.6.1

package/src/main.ts

@@ -17,7 +17,7 @@ import { invalidate as invalidateFsCache } from "./capability/fs";
 import type { Args } from "./cli/args";
 import { processFileArguments } from "./cli/file-processor";
 import { buildInitialMessage } from "./cli/initial-message";
-import { listModels } from "./cli/list-models";
+import { runListModelsCommand } from "./cli/list-models";
 import { selectSession } from "./cli/session-picker";
 import { findConfigFile } from "./config";
 import { ModelRegistry, ModelsConfigFile } from "./config/model-registry";
@@ -604,10 +604,25 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 	}
 
 	if (parsedArgs.listModels !== undefined) {
-		await logger.time("settings:init:list-models", Settings.init, { cwd: getProjectDir() });
+		const settingsInstance = await logger.time("settings:init:list-models", Settings.init, {
+			cwd: getProjectDir(),
+		});
 		await modelRegistry.refresh("online");
+		const cliExtensionPaths = parsedArgs.noExtensions
+			? []
+			: [...(parsedArgs.extensions ?? []), ...(parsedArgs.hooks ?? [])];
+		const settingsExtensions = settingsInstance.get("extensions") ?? [];
+		const disabledExtensionIds = settingsInstance.get("disabledExtensions") ?? [];
 		const searchPattern = typeof parsedArgs.listModels === "string" ? parsedArgs.listModels : undefined;
-		await listModels(modelRegistry, searchPattern);
+		await runListModelsCommand({
+			modelRegistry,
+			cwd: getProjectDir(),
+			additionalExtensionPaths: cliExtensionPaths,
+			settingsExtensions,
+			disabledExtensionIds,
+			disableExtensionDiscovery: Boolean(parsedArgs.noExtensions),
+			searchPattern,
+		});
 		process.exit(0);
 	}
 

package/src/modes/components/session-observer-overlay.ts

@@ -519,11 +519,14 @@ export class SessionObserverOverlayComponent extends Container {
 			case "edit":
 				return args.path ? `path: ${args.path}` : "";
 			case "search":
-				return [args.pattern ? `pattern: ${args.pattern}` : "", args.path ? `path: ${args.path}` : ""]
+				return [
+					args.pattern ? `pattern: ${args.pattern}` : "",
+					Array.isArray(args.paths) ? `paths: ${args.paths.join(", ")}` : "",
+				]
 					.filter(Boolean)
 					.join(", ");
 			case "find":
-				return args.pattern ? `pattern: ${args.pattern}` : "";
+				return Array.isArray(args.paths) ? `paths: ${args.paths.join(", ")}` : "";
 			case "bash": {
 				const cmd = args.command;
 				return typeof cmd === "string" ? replaceTabs(cmd) : "";

package/src/modes/components/status-line/segments.ts

@@ -366,7 +366,7 @@ const sessionNameSegment: StatusLineSegment = {
 	id: "session_name",
 	render(ctx) {
 		const sessionManager = ctx.session.sessionManager;
-		const name = sessionManager?.titleSource === "auto" ? undefined : sessionManager?.getSessionName();
+		const name = sessionManager?.getSessionName();
 		if (!name) return { content: "", visible: false };
 
 		const ansi = getSessionAccentAnsi(getSessionAccentHex(name)) ?? theme.getFgAnsi("accent");

package/src/modes/components/status-line.ts

@@ -9,7 +9,7 @@ import { theme } from "../../modes/theme/theme";
 import type { AgentSession } from "../../session/agent-session";
 import { calculatePromptTokens } from "../../session/compaction/compaction";
 import * as git from "../../utils/git";
-import { getSessionAccentAnsi, getSessionAccentHexForTitle } from "../../utils/session-color";
+import { getSessionAccentAnsi, getSessionAccentHex } from "../../utils/session-color";
 import { sanitizeStatusText } from "../shared";
 import {
 	canReuseCachedPr,
@@ -514,10 +514,8 @@ export class StatusLineComponent implements Component {
 		leftWidth = groupWidth(left, leftCapWidth, leftSepWidth);
 		rightWidth = groupWidth(right, rightCapWidth, rightSepWidth);
 		const gapWidth = Math.max(1, topFillWidth - leftWidth - rightWidth);
-		const accentHex = getSessionAccentHexForTitle(
-			this.session.sessionManager?.getSessionName(),
-			this.session.sessionManager?.titleSource,
-		);
+		const sessionName = this.session.sessionManager?.getSessionName();
+		const accentHex = sessionName ? getSessionAccentHex(sessionName) : undefined;
 		const gapColor = getSessionAccentAnsi(accentHex) ?? theme.getFgAnsi("border");
 		const gapFill = `${gapColor}${theme.boxRound.horizontal.repeat(gapWidth)}\x1b[39m`;
 		return leftGroup + gapFill + rightGroup;

package/src/modes/components/tree-selector.ts

@@ -667,13 +667,12 @@ class TreeList implements Component {
 			}
 			case "search": {
 				const pattern = String(args.pattern || "");
-				const path = shortenPath(String(args.path || "."));
-				return `[search: /${pattern}/ in ${path}]`;
+				const paths = Array.isArray(args.paths) ? args.paths.join(", ") : String(args.path || ".");
+				return `[search: /${pattern}/ in ${shortenPath(paths)}]`;
 			}
 			case "find": {
-				const pattern = String(args.pattern || "");
-				const path = shortenPath(String(args.path || "."));
-				return `[find: ${pattern} in ${path}]`;
+				const paths = Array.isArray(args.paths) ? args.paths.join(", ") : String(args.pattern || ".");
+				return `[find: ${shortenPath(paths)}]`;
 			}
 			case "ls": {
 				const path = shortenPath(String(args.path || "."));

package/src/modes/components/welcome.ts

@@ -94,9 +94,19 @@ export class WelcomeComponent implements Component {
 		if (this.recentSessions.length === 0) {
 			sessionLines.push(` ${theme.fg("dim", "No recent sessions")}`);
 		} else {
+			// Reserve width for the bullet prefix (" • ") and the trailing " (timeAgo)"
+			// so the relative time is never the part that gets truncated. The name
+			// absorbs whatever space is left.
+			const bulletPrefix = ` ${theme.md.bullet} `;
+			const prefixWidth = visibleWidth(bulletPrefix);
 			for (const session of this.recentSessions.slice(0, 3)) {
+				const timeSuffixRaw = ` (${session.timeAgo})`;
+				const timeWidth = visibleWidth(timeSuffixRaw);
+				const nameBudget = Math.max(1, rightCol - prefixWidth - timeWidth);
+				const nameVis = visibleWidth(session.name);
+				const name = nameVis > nameBudget ? truncateToWidth(session.name, nameBudget) : session.name;
 				sessionLines.push(
-					` ${theme.fg("dim", `${theme.md.bullet} `)}${theme.fg("muted", session.name)}${theme.fg("dim", ` (${session.timeAgo})`)}`,
+					`${theme.fg("dim", bulletPrefix)}${theme.fg("muted", name)}${theme.fg("dim", timeSuffixRaw)}`,
 				);
 			}
 		}

package/src/modes/controllers/command-controller.ts

@@ -626,11 +626,7 @@ export class CommandController {
 		}
 		if (!(await this.ctx.session.newSession(options))) return;
 		this.ctx.resetObserverRegistry();
-		setSessionTerminalTitle(
-			this.ctx.sessionManager.getSessionName(),
-			this.ctx.sessionManager.getCwd(),
-			this.ctx.sessionManager.titleSource,
-		);
+		setSessionTerminalTitle(this.ctx.sessionManager.getSessionName(), this.ctx.sessionManager.getCwd());
 
 		this.ctx.statusLine.invalidate();
 		this.ctx.statusLine.setSessionStartTime(Date.now());
@@ -747,7 +743,7 @@ export class CommandController {
 				return;
 			}
 			const name = this.ctx.sessionManager.getSessionName()!;
-			setSessionTerminalTitle(name, this.ctx.sessionManager.getCwd(), this.ctx.sessionManager.titleSource);
+			setSessionTerminalTitle(name, this.ctx.sessionManager.getCwd());
 			this.ctx.statusLine.invalidate();
 			this.ctx.updateEditorBorderColor();
 			this.ctx.showStatus(`Session renamed to "${name}".`);

package/src/modes/controllers/event-controller.ts

@@ -110,8 +110,11 @@ export class EventController {
 		assistantComponent.setToolResultImages(toolCallId, images);
 		return true;
 	}
-	#updateWorkingMessageFromIntent(intent: string | undefined): void {
-		const trimmed = intent?.trim();
+	#updateWorkingMessageFromIntent(intent: unknown): void {
+		// Streamed JSON can deliver non-string `_i` (object, number, boolean) before
+		// schema validation; `?.` only guards null/undefined, so guard the type too.
+		if (typeof intent !== "string") return;
+		const trimmed = intent.trim();
 		if (!trimmed || trimmed === this.#lastIntent) return;
 		this.#lastIntent = trimmed;
 		this.ctx.setWorkingMessage(`${trimmed} (esc to interrupt)`);
@@ -288,7 +291,7 @@ export class EventController {
 				const args = content.arguments;
 				if (!args || typeof args !== "object") continue;
 				if (INTENT_FIELD in args) {
-					this.#updateWorkingMessageFromIntent(args[INTENT_FIELD] as string | undefined);
+					this.#updateWorkingMessageFromIntent(args[INTENT_FIELD]);
 					continue;
 				}
 				const tool = this.ctx.session.getToolByName(content.name);
@@ -678,8 +681,7 @@ export class EventController {
 		if (this.ctx.isBackgrounded === false) return;
 		const notify = settings.get("completion.notify");
 		if (notify === "off") return;
-		const title =
-			this.ctx.sessionManager.titleSource === "auto" ? undefined : this.ctx.sessionManager.getSessionName();
+		const title = this.ctx.sessionManager.getSessionName();
 		const message = title ? `${title}: Complete` : "Complete";
 		TERMINAL.sendNotification(message);
 	}

package/src/modes/controllers/extension-ui-controller.ts

@@ -150,11 +150,7 @@ export class ExtensionUiController {
 				if (!success) {
 					return { cancelled: true };
 				}
-				setSessionTerminalTitle(
-					this.ctx.sessionManager.getSessionName(),
-					this.ctx.sessionManager.getCwd(),
-					this.ctx.sessionManager.titleSource,
-				);
+				setSessionTerminalTitle(this.ctx.sessionManager.getSessionName(), this.ctx.sessionManager.getCwd());
 
 				// Call setup callback if provided
 				if (options?.setup) {
@@ -223,11 +219,7 @@ export class ExtensionUiController {
 				if (!result) {
 					return { cancelled: true };
 				}
-				setSessionTerminalTitle(
-					this.ctx.sessionManager.getSessionName(),
-					this.ctx.sessionManager.getCwd(),
-					this.ctx.sessionManager.titleSource,
-				);
+				setSessionTerminalTitle(this.ctx.sessionManager.getSessionName(), this.ctx.sessionManager.getCwd());
 				this.ctx.chatContainer.clear();
 				this.ctx.renderInitialMessages();
 				await this.ctx.reloadTodos();
@@ -875,11 +867,7 @@ export class ExtensionUiController {
 
 	async #updateSessionName(name: string): Promise<void> {
 		await this.ctx.sessionManager.setSessionName(name, "user");
-		setSessionTerminalTitle(
-			this.ctx.sessionManager.getSessionName(),
-			this.ctx.sessionManager.getCwd(),
-			this.ctx.sessionManager.titleSource,
-		);
+		setSessionTerminalTitle(this.ctx.sessionManager.getSessionName(), this.ctx.sessionManager.getCwd());
 	}
 
 	#sendExtensionUserMessage: SendUserMessageHandler = (content, options) => {

package/src/modes/controllers/input-controller.ts

@@ -367,7 +367,6 @@ export class InputController {
 								setSessionTerminalTitle(
 									this.ctx.sessionManager.getSessionName()!,
 									this.ctx.sessionManager.getCwd(),
-									this.ctx.sessionManager.titleSource,
 								);
 								this.ctx.updateEditorBorderColor();
 							}

package/src/modes/controllers/selector-controller.ts

@@ -750,7 +750,7 @@ export class SelectorController {
 			getCwd: () => string;
 			titleSource?: "auto" | "user" | undefined;
 		};
-		setSessionTerminalTitle(sessionManager.getSessionName?.(), sessionManager.getCwd(), sessionManager.titleSource);
+		setSessionTerminalTitle(sessionManager.getSessionName?.(), sessionManager.getCwd());
 	}
 
 	async #detachActiveSessionBeforeDeletion(sessionPath: string): Promise<boolean> {

package/src/modes/interactive-mode.ts

@@ -51,7 +51,7 @@ import { normalizeLocalScheme } from "../tools/path-utils";
 import { formatPhaseDisplayName } from "../tools/todo-write";
 import type { EventBus } from "../utils/event-bus";
 import { getEditorCommand, openInEditor } from "../utils/external-editor";
-import { getSessionAccentAnsi, getSessionAccentHexForTitle } from "../utils/session-color";
+import { getSessionAccentAnsi, getSessionAccentHex } from "../utils/session-color";
 import { popTerminalTitle, pushTerminalTitle, setSessionTerminalTitle } from "../utils/title-generator";
 import type { AssistantMessageComponent } from "./components/assistant-message";
 import type { BashExecutionComponent } from "./components/bash-execution";
@@ -275,6 +275,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#syncEditorMaxHeight();
 		this.#resizeHandler = () => {
 			this.#syncEditorMaxHeight();
+			this.updateEditorTopBorder();
 		};
 		process.stdout.on("resize", this.#resizeHandler);
 		try {
@@ -431,11 +432,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		// Start the UI
 		this.ui.start();
 		pushTerminalTitle();
-		setSessionTerminalTitle(
-			this.sessionManager.getSessionName(),
-			this.sessionManager.getCwd(),
-			this.sessionManager.titleSource,
-		);
+		setSessionTerminalTitle(this.sessionManager.getSessionName(), this.sessionManager.getCwd());
 		this.updateEditorBorderColor();
 		this.#syncEditorMaxHeight();
 		this.isInitialized = true;
@@ -647,7 +644,8 @@ export class InteractiveMode implements InteractiveModeContext {
 		} else if (this.isPythonMode) {
 			this.editor.borderColor = theme.getPythonModeBorderColor();
 		} else {
-			const hex = getSessionAccentHexForTitle(this.sessionManager.getSessionName(), this.sessionManager.titleSource);
+			const sessionName = this.sessionManager.getSessionName();
+			const hex = sessionName ? getSessionAccentHex(sessionName) : undefined;
 			const ansi = getSessionAccentAnsi(hex);
 			if (ansi) {
 				this.editor.borderColor = (str: string) => `${ansi}${str}\x1b[39m`;

package/src/prompts/system/system-prompt.md

@@ -77,23 +77,22 @@ If any check fails, continue or mark [blocked]. Do **NOT** reframe partial work
 - Correctness first, brevity second, politeness third.
 - Prefer concise, information-dense writing.
 - Avoid repeating the user's request or narrating routine tool calls.
+- Prefer tool output over prose explanation — tool results communicate directly; narration adds noise, not signal.
 - Do not give time estimates or predictions.
 - Do not emit closing summaries, recap paragraphs, or "what I did" wrap-ups. Final messages state the result and any blockers; the trace already shows the work.
 </communication>
 
 <output-contract>
-- Brief preambles are allowed when they improve orientation, but they **MUST** stay short and **MUST NOT** be treated as completion.
 - A phase boundary, todo flip, or completed sub-step is **NOT** a yield point. Continue directly to the next step in the same turn — do **NOT** stop to summarize, ask for acknowledgement, or wait for the user to say "go".
 - Yield only when (a) the whole deliverable is complete, (b) you are [blocked], or (c) the user asked a question that requires their input.
 - Claims about code, tools, tests, docs, or external sources **MUST** be grounded in what was actually observed.
-- If a statement is an inference, label it as such.
+- Persist on hard problems; do **NOT** punt half-solved work back
 - Be brief in prose, not in evidence, verification, or blocking details.
 </output-contract>
 
 <default-follow-through>
 - If the user's intent is clear and the next step is low-risk, proceed without asking.
 - Ask only when the next step is irreversible, has external side effects, or requires a missing choice that materially changes the outcome.
-- If you proceed, state what you did, what you verified, and what remains optional.
 </default-follow-through>
 
 <behavior>
@@ -138,20 +137,6 @@ Edge cases you ignored: pages at 3am.
 - Tests you did not write are bugs shipped; edge cases you ignored are pages at 3am. In this high-reliability domain, write only code you can defend and surface uncertainty explicitly.
 </principles>
 
-<design-checklist>
-Before writing or refactoring, verify:
-- Caller expectations are explicit
-- Failure modes surface the truth rather than plausible lies
-- Interfaces preserve distinctions the domain already knows
-- Existing repository patterns were considered before introducing new ones
-- The simpler design has been considered
-- Compiling is not correctness: verify behavior under the conditions that actually occur, including the failure modes
-- Adversarial caller: what does a malicious caller do? what would a tired maintainer misunderstand?
-- Cost named: before choosing the easy path, name what it costs (duplicated pattern across N files, unbounded resource use, escape hatch through the type system)
-- Inhabit the call site: read your own change as someone who has never seen the implementation — does the interface reflect what happened? is any input silently discarded?
-- Persist on hard problems; do **NOT** punt half-solved work back
-</design-checklist>
-
 {{SECTION_SEPARATOR "Environment"}}
 
 You operate inside the Oh My Pi coding harness. Given a task, you **MUST** complete it using the tools available to you.
@@ -288,6 +273,7 @@ Don't open a file hoping. Hope is not a strategy.
 {{#has tools "find"}}- Use `{{toolRefs.find}}` to map structure.{{/has}}
 {{#has tools "read"}}- Use `{{toolRefs.read}}` with offset or limit rather than whole-file reads when practical.{{/has}}
 {{#has tools "task"}}- Use `{{toolRefs.task}}` for investigate+edit when available.{{/has}}
+- Load into context only what is necessary. Do not read files you do not need; do not fetch sections beyond what the task requires.
 <tool-persistence>
 - Use tools whenever they materially improve correctness, completeness, or grounding.
 - Do not stop at the first plausible answer if another tool call would materially reduce uncertainty.
@@ -322,15 +308,6 @@ These are inviolable.
 - If something is blocked, label it [blocked], say exactly what is missing, and distinguish it from work that is complete.
 </completeness-contract>
 
-# Design Integrity
-
-Design integrity means the code tells the truth about what the system currently is — not what it used to be, not what was convenient to patch. Every vestige of old design left compilable and reachable is a lie told to the next reader.
-- **The unit of change is the design decision, not the feature.** When something changes, everything that represents, names, documents, or tests it changes with it — in the same change. A refactor that introduces a new abstraction while leaving the old one reachable isn't done. A feature that requires a compatibility wrapper to land isn't done. The work is complete when the design is coherent, not when the tests pass.
-- **One concept, one representation.** Parallel APIs, shims, and wrapper types that exist only to bridge a mismatch don't solve the design problem — they defer its cost indefinitely, and it compounds. Every conversion layer between two representations is code the next reader must understand before they can change anything. Pick one representation, migrate everything to it, delete the other.
-- **Abstractions must cover their domain completely.** An abstraction that handles 80% of a concept — with callers reaching around it for the rest — gives the appearance of encapsulation without the reality. It also traps the next caller: they follow the pattern and get the wrong answer for their case. If callers routinely work around an abstraction, its boundary is wrong. Fix the boundary.
-- **Types must preserve what the domain knows.** Collapsing structured information into a coarser representation — a boolean, a string where an enum belongs, a nullable where a tagged union belongs — discards distinctions the type system could have enforced. Downstream code that needed those distinctions now reconstructs them heuristically or silently operates on impoverished data. The right type is the one that can represent everything the domain requires, not the one most convenient for the current caller.
-- **Optimize for the next edit, not the current diff.** After any change, ask: what does the person who touches this next have to understand? If they have to decode why two representations coexist, what a "temporary" bridge is doing, or which of two APIs is canonical — the work isn't done.
-
 # Procedure
 ## 1. Scope
 {{#if skills.length}}- You **MUST** read skills that match the task domain before starting.{{/if}}
@@ -353,6 +330,7 @@ Design integrity means the code tells the truth about what the system currently
 > a. Semantic edits to files that don't import each other or share types being changed
 > b. Investigating multiple subsystems
 > c. Work that decomposes into independent pieces wired together at the end
+- Multiple edits to different sections of the same file are independent — stable hash anchors make them safe to batch. Issue them in one response rather than sequentially.
 - When a plan feels too large for a single turn, parallelize aggressively — do **NOT** abandon phases, silently drop them, or narrate scope cuts. Scope pressure is a signal to delegate, not to shrink the work.
 {{/has}}
 - Justify sequential work; default parallel. If you cannot articulate why B depends on A, it doesn't.
@@ -362,18 +340,16 @@ Design integrity means the code tells the truth about what the system currently
 - Marking a todo done is a transition, not a stop: in the same turn, start the next pending todo. Acceptable inter-phase text is one short line ("phase 1 done, starting phase 2") — not a recap, not a question.
 
 ## 5. While working
-You are not making code that works. You are making code that communicates — to callers, to the system it lives in, to whoever changes it next.
-- **One job, one level of abstraction.** If you need "and" to describe what something does, it should be two things. Code that mixes levels — orchestrating a flow while also handling parsing, formatting, or low-level manipulation — has no coherent owner and no coherent test. Each piece operates at one level and delegates everything else.
-- **Fix where the invariant is violated, not where the violation is observed.** If a function returns the wrong thing, fix the function — not the caller's workaround. If a type is wrong, fix the type — not the cast. The right fix location is always where the contract is broken.
-- **New code makes old code obsolete. Remove it.** When you introduce an abstraction, find what it replaces: old helpers, compatibility branches, stale tests, documentation describing removed behavior. Remove them in the same change.
-- **No forwarding addresses.** Deleted or moved code leaves no trace — no `// moved to X` comments, no re-exports from the old location, no aliases kept "for now," no renaming unused parameters to `_var`, no `// removed` tombstones. If something is unused, delete it completely.
-- **Prefer editing over creating.** Do not create new files unless they are necessary to achieve the goal. Editing an existing file prevents file bloat and builds on existing work. A new file must earn its existence.
-- **After writing, inhabit the call site.** Read your own code as someone who has never seen the implementation. Does the interface honestly reflect what happened? Is any accepted input silently discarded? Does any pattern exist in more than one place? Fix it.
-- When a tool call fails, read the full error before doing anything else. If a file changed since you last read it, re-read before editing.
-{{#has tools "ask"}}- Ask before destructive commands like `git checkout/restore/reset`, overwriting changes, or deleting code you did not write.{{else}}- Do **NOT** run destructive git commands like `git checkout/restore/reset`, overwrite changes, or delete code you did not write.{{/has}}
-{{#has tools "web_search"}}- If stuck or uncertain, gather more information. Do **NOT** pivot approaches without cause.{{/has}}
-- If others may be editing concurrently, re-read changed files and adapt.
-- If blocked, exhaust tools and context first.
+Focus on clarity and correctness. Make code easy to understand now and in the future.
+- Fix problems at their source, not at their symptoms.
+- Remove obsolete or unused code — no leftover comments, aliases, or re-exports.
+- Prefer updating existing files over creating new ones, unless a new file is necessary.
+- After editing, review from a user's perspective. Make sure your changes are clear and the interface matches behavior.
+- If a tool fails or a file changes, re-read before acting.
+{{#has tools "ask"}}- Ask before running destructive commands or deleting code you did not write.{{else}}- Do **NOT** run destructive git commands or delete code you did not write.{{/has}}
+{{#has tools "web_search"}}- If unsure, search for more information instead of guessing.{{/has}}
+- Adapt to concurrent edits by re-reading changed files.
+- Use all available tools and context before declaring a blocker.
 
 ## 6. Verification
 - Test rigorously. Prefer unit or end-to-end tests, you **MUST NOT** rely on mocks.

package/src/prompts/tools/ast-edit.md

@@ -2,8 +2,8 @@ Performs structural AST-aware rewrites via native ast-grep.
 
 <instruction>
 - Use for codemods and structural rewrites where plain text replace is unsafe
-- `path` is required and accepts a file, directory, glob, comma-separated path list, or internal URL
-- Language is inferred from `path`; narrow `path` to one language for deterministic rewrites
+- `paths` is required and accepts an array of files, directories, globs, or internal URLs
+- Language is inferred from `paths`; narrow each call to one language for deterministic rewrites
 - Metavariables captured in `pat` (`$A`, `$$$ARGS`) are substituted into that entry's `out` template
 - **Patterns match AST structure, not text.** `$NAME` = one node (captured); `$_` = one without binding; `$$$NAME` = zero-or-more (lazy — stops at next matchable element); `$$$` = zero-or-more without binding. Use `$$$NAME`, **NOT** `$$NAME` — the two-dollar form is invalid. Metavariable names are UPPERCASE and **MUST** be the whole AST node — partial text like `prefix$VAR` or `"hello $NAME"` does NOT work
 - When the same metavariable appears twice, both occurrences **MUST** match identical code (`$A == $A` matches `x == x`, not `x == y`)
@@ -20,17 +20,17 @@ Performs structural AST-aware rewrites via native ast-grep.
 
 <examples>
 # Rename a call site across TypeScript files
-`{"ops":[{"pat":"oldApi($$$ARGS)","out":"newApi($$$ARGS)"}],"path":"src/**/*.ts"}`
+`{"ops":[{"pat":"oldApi($$$ARGS)","out":"newApi($$$ARGS)"}],"paths":["src/**/*.ts"]}`
 # Delete matching calls
-`{"ops":[{"pat":"console.log($$$ARGS)","out":""}],"path":"src/**/*.ts"}`
+`{"ops":[{"pat":"console.log($$$ARGS)","out":""}],"paths":["src/**/*.ts"]}`
 # Rewrite import source path
-`{"ops":[{"pat":"import { $$$IMPORTS } from \"old-package\"","out":"import { $$$IMPORTS } from \"new-package\""}],"path":"src/**/*.ts"}`
+`{"ops":[{"pat":"import { $$$IMPORTS } from \"old-package\"","out":"import { $$$IMPORTS } from \"new-package\""}],"paths":["src/**/*.ts"]}`
 # Modernize to optional chaining (same metavariable enforces identity)
-`{"ops":[{"pat":"$A && $A()","out":"$A?.()"}],"path":"src/**/*.ts"}`
+`{"ops":[{"pat":"$A && $A()","out":"$A?.()"}],"paths":["src/**/*.ts"]}`
 # Swap two arguments using captures
-`{"ops":[{"pat":"assertEqual($A, $B)","out":"assertEqual($B, $A)"}],"path":"tests/**/*.ts"}`
+`{"ops":[{"pat":"assertEqual($A, $B)","out":"assertEqual($B, $A)"}],"paths":["tests/**/*.ts"]}`
 # Python — convert print calls to logging
-`{"ops":[{"pat":"print($$$ARGS)","out":"logger.info($$$ARGS)"}],"path":"src/**/*.py"}`
+`{"ops":[{"pat":"print($$$ARGS)","out":"logger.info($$$ARGS)"}],"paths":["src/**/*.py"]}`
 </examples>
 
 <critical>

package/src/prompts/tools/ast-grep.md

@@ -2,8 +2,8 @@ Performs structural code search using AST matching via native ast-grep.
 
 <instruction>
 - Use when syntax shape matters more than raw text (calls, declarations, specific language constructs)
-- `path` is required and accepts a file, directory, glob, comma-separated path list, or internal URL
-- Language is inferred from `path`; narrow `path` to one language when mixed-language trees could cause parse noise
+- `paths` is required and accepts an array of files, directories, globs, or internal URLs
+- Language is inferred from `paths`; narrow each call to one language when mixed-language trees could cause parse noise
 - `pat` is a single AST pattern. Run separate calls for distinct unrelated patterns
 - **Patterns match AST structure, not text** — whitespace/formatting is ignored
 - `$NAME` captures one node; `$_` matches one without binding; `$$$NAME` captures zero-or-more (lazy — stops at next matchable element); `$$$` matches zero-or-more without binding. Use `$$$NAME`, **NOT** `$$NAME` — the two-dollar form is invalid and produces a parse error
@@ -13,7 +13,7 @@ Performs structural code search using AST matching via native ast-grep.
 - C++ qualified calls used as expression statements need the statement semicolon in the pattern: use `ns::doThing($ARG);`, `$CALLEE($ARG);`, or wrap a statement snippet. Without `;`, tree-sitter-cpp may parse `ns::doThing($ARG)` as declaration-like syntax and return no matches
 - For TS declarations/methods, tolerate unknown annotations: `async function $NAME($$$ARGS): $_ { $$$BODY }` or `class $_ { method($ARG: $_): $_ { $$$BODY } }`
 - Declaration forms are structurally distinct — top-level `function foo`, class method `foo()`, and `const foo = () => {}` are different AST shapes; search the right form before concluding absence
-- Loosest existence check: `pat: "executeBash"` with a narrow `path`
+- Loosest existence check: `pat: "executeBash"` with narrow `paths`
 </instruction>
 
 <output>
@@ -24,19 +24,19 @@ Performs structural code search using AST matching via native ast-grep.
 
 <examples>
 # Search TypeScript files under src
-`{"pat":"console.log($$$)","path":"src/**/*.ts"}`
+`{"pat":"console.log($$$)","paths":["src/**/*.ts"]}`
 # Named imports from a specific package
-`{"pat":"import { $$$IMPORTS } from \"react\"","path":"src/**/*.ts"}`
+`{"pat":"import { $$$IMPORTS } from \"react\"","paths":["src/**/*.ts"]}`
 # Arrow functions assigned to a const
-`{"pat":"const $NAME = ($$$ARGS) => $BODY","path":"src/utils/**/*.ts"}`
+`{"pat":"const $NAME = ($$$ARGS) => $BODY","paths":["src/utils/**/*.ts"]}`
 # Method call on any object, ignoring method name with `$_`
-`{"pat":"logger.$_($$$ARGS)","path":"src/**/*.ts"}`
+`{"pat":"logger.$_($$$ARGS)","paths":["src/**/*.ts"]}`
 # Loosest existence check for a symbol in one file
-`{"pat":"processItems","path":"src/worker.ts"}`
+`{"pat":"processItems","paths":["src/worker.ts"]}`
 </examples>
 
 <critical>
-- Avoid repo-root scans — narrow `path` first
-- Parse issues are query failure, not evidence of absence: repair the pattern or tighten `path` before concluding "no matches"
+- Avoid repo-root scans — narrow `paths` first
+- Parse issues are query failure, not evidence of absence: repair the pattern or tighten `paths` before concluding "no matches"
 - For broad/open-ended exploration across subsystems, use Task tool with explore subagent first
 </critical>

package/src/prompts/tools/eval.md

@@ -1,17 +1,19 @@
 Run code in a persistent kernel, using a series of codeblocks acting as cells.
 
 <instruction>
-Each cell is a markdown fenced code block. The opening fence's info string carries metadata:
+Each cell is introduced by a header line of the form:
 
 ```
-<lang>? <duration>? (title-fragment | key=value)*
+===== <info> =====
 ```
-- **Language**: {{#if py}}`py`/`python` for Python{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}`js`/`javascript`/`ts`/`typescript` for JavaScript{{/if}}.{{#ifAll py js}} Omitted → inherit the previous cell's language (the first cell defaults to Python, falling back to JavaScript when Python is unavailable).{{else}} Omitted → inherit the previous cell's language.{{/ifAll}}
-- **Positional duration**: `15s`, `500ms`, `2m`, or a bare integer (seconds). Default 30s.
+
+where each side is at least 5 equal signs. Everything between one header and the next (or end of input) is the cell's code, verbatim. The info is space-separated tokens, all optional, in any order:
+- **Language**: {{#if py}}`py` for Python{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}`js` / `ts` for JavaScript{{/if}}.{{#ifAll py js}} Omitted → inherit the previous cell's language (the first cell defaults to Python, falling back to JavaScript when Python is unavailable).{{else}} Omitted → inherit the previous cell's language.{{/ifAll}}
+- **Title shorthand**: `py:"…"`, `js:"…"`, `ts:"…"` set the language and the cell title together.
 - **Attributes**:
-  - `id="…"` — cell id (shown as the title in the transcript).
-  - `t=<duration>` — overrides the positional duration.
-  - `rst=true` — wipe **this cell's own language kernel** before running.{{#ifAll py js}} Other languages are untouched.{{/ifAll}}
+  - `id:"…"` — cell title (when language is unchanged or already set).
+  - `t:<duration>` — per-cell timeout. Duration is digits with optional `ms` / `s` / `m` units (e.g. `t:500ms`, `t:15s`, `t:2m`). Default 30s.
+  - `rst` — wipe **this cell's own language kernel** before running.{{#ifAll py js}} Other languages are untouched.{{/ifAll}}
 
 **Work incrementally:** one logical step per cell (imports, define, test, use). Pass multiple small cells in one call. Define small reusable functions you can debug individually. You **MUST** put workflow explanations in the assistant message or cell title — never inside cell code.
 
@@ -31,18 +33,6 @@ write(path, content) → str
     Write content to a file (creates parent directories). Returns the resolved path.
 append(path, content) → str
     Append content to a file. Returns the resolved path.
-stat(path) → {path, size, is_file, is_dir, mtime}
-    File or directory metadata. mtime is an ISO-8601 string.
-find(pattern, path?=".", type?="file", limit?=1000, hidden?=False, sort_by_mtime?=False, maxdepth?=None, mindepth?=None) → list[path]
-    Recursive glob find. Respects .gitignore.
-glob(pattern, path?=".", hidden?=False) → list[path]
-    Non-recursive glob. Use find() for recursive walks. Respects .gitignore.
-grep(pattern, path, ignore_case?=False, literal?=False, context?=0) → list[{line, text}]
-    Search a single file.
-rgrep(pattern, path?=".", glob_pattern?="*", ignore_case?=False, literal?=False, limit?=100, hidden?=False) → list[{file, line, text}]
-    Search recursively across files. Respects .gitignore.
-sed(path, pattern, repl, flags?=0) → int
-    Regex replace in a file (like sed -i). Returns replacement count.
 tree(path?=".", max_depth?=3, show_hidden?=False) → str
     Render a directory tree.
 diff(a, b) → str
@@ -63,30 +53,22 @@ Cells render like a Jupyter notebook. Pass any value to `display(value)`; non-pr
 </output>
 
 <caution>
-- In session mode, use `rst=true` on a cell to wipe its language's kernel before running.{{#ifAll py js}} Reset is per-language: a python cell's `rst=true` does not touch the JavaScript kernel and vice versa.{{/ifAll}}
+- In session mode, use `rst` on a cell to wipe its language's kernel before running.{{#ifAll py js}} Reset is per-language: a python cell's `rst` does not touch the JavaScript kernel and vice versa.{{/ifAll}}
 {{#if js}}- **js**: the VM exposes a selective `process` subset, Web APIs, `Buffer`, `fs/promises`.
 {{/if}}</caution>
 
 <example>
-{{#if py}}```py id="imports" t="10s"
+{{#if py}}===== py:"imports" t:10s =====
 import json
 from pathlib import Path
-```
 
-```py id="load config"
+===== py:"load config" =====
 data = json.loads(read('package.json'))
 display(data)
-```
 {{/if}}{{#ifAll py js}}
-
-{{/ifAll}}{{#if js}}```js id="js summary" rst=true
+{{/ifAll}}{{#if js}}===== js:"js summary" rst =====
 const data = JSON.parse(await read('package.json'));
 display(data);
 return data.name;
-```
-
-```
-return 'still JavaScript';
-```
 {{/if}}
 </example>

package/src/prompts/tools/find.md

@@ -1,6 +1,7 @@
 Finds files using fast pattern matching that works with any codebase size.
 
 <instruction>
+- `paths` is required and accepts an array of globs, files, or directories
 - You **SHOULD** perform multiple searches in parallel when potentially useful
 </instruction>
 
@@ -10,7 +11,7 @@ Matching file paths sorted by modification time (most recent first). Truncated a
 
 <examples>
 # Find files
-`{"pattern": "src/**/*.ts", "limit": 1000}`
+`{"paths": ["src/**/*.ts"], "limit": 1000}`
 </examples>
 
 <avoid>