@oh-my-pi/pi-coding-agent 15.5.15 → 15.7.0

package/src/modes/setup-wizard/wizard-overlay.ts

@@ -0,0 +1,275 @@
+import { type Component, matchesKey, padding, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
+import { APP_NAME } from "@oh-my-pi/pi-utils";
+import { gradientLogo, PI_LOGO } from "../components/welcome";
+import { theme } from "../theme/theme";
+import type { InteractiveModeContext } from "../types";
+import { renderSetupOutro, SETUP_OUTRO_MS } from "./scenes/outro";
+import { renderSetupSplash, SETUP_SPLASH_MS, SETUP_TICK_MS } from "./scenes/splash";
+import type { SetupScene, SetupSceneController, SetupSceneHost, SetupSceneResult } from "./scenes/types";
+
+type WizardPhase = "splash" | "transition" | "scene" | "outro" | "done";
+
+const SCENE_MARGIN_X = 4;
+const MIN_CONTENT_WIDTH = 20;
+/** Cross-dissolve duration from the splash into the first scene. */
+const SCENE_TRANSITION_MS = 420;
+
+function centerLine(line: string, width: number): string {
+	const lineWidth = visibleWidth(line);
+	if (lineWidth >= width) return truncateToWidth(line, width);
+	const left = Math.floor((width - lineWidth) / 2);
+	return padding(left) + line + padding(width - left - lineWidth);
+}
+
+function clampLine(line: string, width: number): string {
+	const truncated = truncateToWidth(line, width);
+	return truncated + padding(Math.max(0, width - visibleWidth(truncated)));
+}
+
+function indentLine(line: string, width: number, indent: number): string {
+	const prefix = padding(Math.min(indent, Math.max(0, width - 1)));
+	return clampLine(prefix + line, width);
+}
+/** Stable per-row jitter in [0,1) for the dissolve reveal order. */
+function rowNoise(y: number): number {
+	const h = Math.imul(y ^ 0x9e3779b9, 2654435761);
+	return ((h ^ (h >>> 15)) >>> 0) / 4294967296;
+}
+
+/**
+ * Top-biased cross-dissolve between two equal-height frames. As `progress`
+ * (0..1) advances, each row flips from `from` to `to` once it crosses a per-row
+ * threshold — top rows reveal first (so the scene's mark/header materializes
+ * before the splash water below it), with a little jitter for an organic edge.
+ */
+function dissolveFrames(from: string[], to: string[], progress: number, height: number): string[] {
+	const eased = progress * progress * (3 - 2 * progress);
+	const denom = Math.max(1, height - 1);
+	const out: string[] = [];
+	for (let y = 0; y < height; y++) {
+		const threshold = 0.78 * (y / denom) + 0.22 * rowNoise(y);
+		out.push((eased >= threshold ? to[y] : from[y]) ?? "");
+	}
+	return out;
+}
+
+export class SetupWizardComponent implements Component {
+	#phase: WizardPhase = "splash";
+	#phaseStartedAt = performance.now();
+	#sceneIndex = 0;
+	#activeScene: SetupSceneController | undefined;
+	#timer: NodeJS.Timeout | undefined;
+	#done = Promise.withResolvers<void>();
+	#disposed = false;
+
+	constructor(
+		readonly ctx: InteractiveModeContext,
+		readonly scenes: readonly SetupScene[],
+	) {}
+
+	run(): Promise<void> {
+		this.#phase = this.scenes.length === 0 ? "outro" : "splash";
+		this.#phaseStartedAt = performance.now();
+		this.#startTimer();
+		this.ctx.ui.requestRender();
+		return this.#done.promise;
+	}
+
+	dispose(): void {
+		this.#disposed = true;
+		this.#stopTimer();
+		this.#unmountActiveScene();
+	}
+
+	invalidate(): void {
+		this.#activeScene?.invalidate();
+	}
+
+	handleInput(data: string): void {
+		if (this.#phase === "done") return;
+		if (matchesKey(data, "ctrl+c")) {
+			this.#beginOutro();
+			return;
+		}
+		if (this.#phase === "splash") {
+			if (
+				matchesKey(data, "enter") ||
+				matchesKey(data, "return") ||
+				matchesKey(data, "space") ||
+				matchesKey(data, "escape")
+			) {
+				this.#beginScene();
+			}
+			return;
+		}
+		if (this.#phase === "outro") {
+			if (
+				matchesKey(data, "enter") ||
+				matchesKey(data, "return") ||
+				matchesKey(data, "space") ||
+				matchesKey(data, "escape")
+			) {
+				this.#complete();
+			}
+			return;
+		}
+		this.#activeScene?.handleInput?.(data);
+	}
+
+	render(width: number): string[] {
+		const safeWidth = Math.max(1, width);
+		const height = Math.max(1, this.ctx.ui.terminal.rows);
+		let lines: string[];
+		switch (this.#phase) {
+			case "splash":
+				lines = renderSetupSplash(safeWidth, height, performance.now() - this.#phaseStartedAt);
+				break;
+			case "transition": {
+				const elapsed = performance.now() - this.#phaseStartedAt;
+				const progress = Math.min(1, elapsed / SCENE_TRANSITION_MS);
+				const splash = renderSetupSplash(safeWidth, height, SETUP_SPLASH_MS + elapsed);
+				const scene = this.#renderScene(safeWidth, height);
+				lines = dissolveFrames(splash, scene, progress, height);
+				break;
+			}
+			case "outro":
+				lines = renderSetupOutro(safeWidth, height, performance.now() - this.#phaseStartedAt);
+				break;
+			case "scene":
+				lines = this.#renderScene(safeWidth, height);
+				break;
+			case "done":
+				lines = [];
+				break;
+		}
+		return this.#fitToScreen(lines, safeWidth, height);
+	}
+
+	#renderScene(width: number, height: number): string[] {
+		const scene = this.scenes[this.#sceneIndex];
+		const title = this.#activeScene?.title ?? scene?.title ?? "Setup";
+		const subtitle = this.#activeScene?.subtitle;
+		const contentWidth = Math.max(MIN_CONTENT_WIDTH, width - SCENE_MARGIN_X * 2);
+		const logo = gradientLogo(PI_LOGO, 0);
+		const header = [
+			"",
+			...logo.map(line => centerLine(line, width)),
+			centerLine(theme.bold(theme.fg("accent", APP_NAME)), width),
+			centerLine(theme.fg("muted", `Setup step ${this.#sceneIndex + 1} of ${this.scenes.length}`), width),
+			"",
+			indentLine(theme.bold(title), width, SCENE_MARGIN_X),
+		];
+		if (subtitle) {
+			header.push(indentLine(theme.fg("muted", subtitle), width, SCENE_MARGIN_X));
+		}
+		header.push("");
+
+		const footer = [
+			"",
+			centerLine(theme.fg("dim", "↑/↓ select · enter confirm · esc skip · ctrl+c exit setup"), width),
+		];
+		const maxBodyLines = Math.max(0, height - header.length - footer.length);
+		const body = this.#activeScene?.render(contentWidth).slice(0, maxBodyLines) ?? [];
+		const lines = [...header, ...body.map(line => indentLine(line, width, SCENE_MARGIN_X))];
+		while (lines.length + footer.length < height) {
+			lines.push("");
+		}
+		lines.push(...footer);
+		return lines;
+	}
+
+	#fitToScreen(lines: string[], width: number, height: number): string[] {
+		const fitted = lines.slice(0, height).map(line => clampLine(line, width));
+		while (fitted.length < height) {
+			fitted.push(padding(width));
+		}
+		return fitted;
+	}
+
+	#startTimer(): void {
+		if (this.#timer) return;
+		this.#timer = setInterval(() => {
+			if (this.#disposed) return;
+			const elapsed = performance.now() - this.#phaseStartedAt;
+			if (this.#phase === "splash" && elapsed >= SETUP_SPLASH_MS) {
+				this.#beginScene();
+			} else if (this.#phase === "transition" && elapsed >= SCENE_TRANSITION_MS) {
+				this.#phase = "scene";
+				this.#phaseStartedAt = performance.now();
+				this.ctx.ui.requestRender();
+			} else if (this.#phase === "outro" && elapsed >= SETUP_OUTRO_MS) {
+				this.#complete();
+			} else {
+				this.ctx.ui.requestRender();
+			}
+		}, SETUP_TICK_MS);
+	}
+
+	#stopTimer(): void {
+		if (!this.#timer) return;
+		clearInterval(this.#timer);
+		this.#timer = undefined;
+	}
+
+	#mountSceneController(targetPhase: "scene" | "transition"): void {
+		if (this.#disposed) return;
+		this.#unmountActiveScene();
+		if (this.#sceneIndex >= this.scenes.length) {
+			this.#beginOutro();
+			return;
+		}
+		const scene = this.scenes[this.#sceneIndex];
+		const host: SetupSceneHost = {
+			ctx: this.ctx,
+			requestRender: () => this.ctx.ui.requestRender(),
+			finish: (_result: SetupSceneResult) => this.#finishScene(),
+			setFocus: component => this.ctx.ui.setFocus(component),
+			restoreFocus: () => this.ctx.ui.setFocus(this),
+		};
+		this.#activeScene = scene.mount(host);
+		this.#phase = targetPhase;
+		this.#phaseStartedAt = performance.now();
+		this.ctx.ui.setFocus(this);
+		void this.#activeScene.onMount?.();
+		this.ctx.ui.requestRender();
+	}
+
+	/** Enter the first scene through a dissolve from the splash. */
+	#beginScene(): void {
+		this.#mountSceneController("transition");
+	}
+
+	#mountCurrentScene(): void {
+		this.#mountSceneController("scene");
+	}
+
+	#finishScene(): void {
+		if (this.#phase !== "scene" && this.#phase !== "transition") return;
+		this.#unmountActiveScene();
+		this.#sceneIndex += 1;
+		this.#mountCurrentScene();
+	}
+
+	#unmountActiveScene(): void {
+		this.#activeScene?.onUnmount?.();
+		this.#activeScene?.dispose?.();
+		this.#activeScene = undefined;
+	}
+
+	#beginOutro(): void {
+		if (this.#phase === "done") return;
+		this.#unmountActiveScene();
+		this.#phase = "outro";
+		this.#phaseStartedAt = performance.now();
+		this.ctx.ui.setFocus(this);
+		this.#startTimer();
+		this.ctx.ui.requestRender();
+	}
+
+	#complete(): void {
+		if (this.#phase === "done") return;
+		this.#phase = "done";
+		this.#stopTimer();
+		this.#done.resolve();
+	}
+}

package/src/modes/theme/shimmer.ts

@@ -147,6 +147,11 @@ function resolveMode(): ShimmerMode {
 	return settings.get("display.shimmer");
 }
 
+/** Whether shimmer animations are active (any mode other than `disabled`). */
+export function shimmerEnabled(): boolean {
+	return resolveMode() !== "disabled";
+}
+
 /**
  * Apply a shimmer sweep across one or more segments, treating them as a
  * single continuous string for band positioning. Each segment can supply

package/src/modes/theme/theme.ts

@@ -1310,6 +1310,24 @@ export class Theme {
 		return ansi;
 	}
 
+	/**
+	 * Foreground ANSI for text drawn **on top of** `fillColor` used as a solid
+	 * background (e.g. a powerline chip). Picks near-black or near-white by the
+	 * fill's perceived luminance (Rec. 601 luma) so the label stays legible on
+	 * both bright and dark fills, across light and dark themes.
+	 *
+	 * Reads the RGB out of the already-resolved truecolor escape; when the fill
+	 * is encoded as a 256-palette index (limited terminals) the RGB is
+	 * unavailable, so it falls back to the theme `text` color.
+	 */
+	getContrastFgAnsi(fillColor: ThemeColor): string {
+		const ansi = this.#fgColors[fillColor];
+		const match = ansi ? /38;2;(\d+);(\d+);(\d+)/.exec(ansi) : null;
+		if (!match) return this.#fgColors.text;
+		const luma = 0.299 * Number(match[1]) + 0.587 * Number(match[2]) + 0.114 * Number(match[3]);
+		return luma > 140 ? "\x1b[38;2;0;0;0m" : "\x1b[38;2;255;255;255m";
+	}
+
 	getColorMode(): ColorMode {
 		return this.mode;
 	}
@@ -1929,17 +1947,20 @@ export function setThemeInstance(themeInstance: Theme): void {
  */
 export async function setSymbolPreset(preset: SymbolPreset): Promise<void> {
 	currentSymbolPresetOverride = preset;
-	if (currentThemeName) {
-		try {
-			theme = await loadTheme(currentThemeName, getCurrentThemeOptions());
-		} catch {
-			// Fall back to dark theme with new preset
-			theme = await loadTheme("dark", getCurrentThemeOptions());
-		}
-		if (onThemeChangeCallback) {
-			onThemeChangeCallback();
-		}
+	if (!currentThemeName) return;
+
+	const requestId = ++themeLoadRequestId;
+	try {
+		const loadedTheme = await loadTheme(currentThemeName, getCurrentThemeOptions());
+		if (requestId !== themeLoadRequestId) return;
+		theme = loadedTheme;
+	} catch {
+		if (requestId !== themeLoadRequestId) return;
+		// Fall back to dark theme with new preset
+		theme = await loadTheme("dark", getCurrentThemeOptions());
+		if (requestId !== themeLoadRequestId) return;
 	}
+	onThemeChangeCallback?.();
 }
 
 /**
@@ -1955,17 +1976,20 @@ export function getSymbolPresetOverride(): SymbolPreset | undefined {
  */
 export async function setColorBlindMode(enabled: boolean): Promise<void> {
 	currentColorBlindMode = enabled;
-	if (currentThemeName) {
-		try {
-			theme = await loadTheme(currentThemeName, getCurrentThemeOptions());
-		} catch {
-			// Fall back to dark theme
-			theme = await loadTheme("dark", getCurrentThemeOptions());
-		}
-		if (onThemeChangeCallback) {
-			onThemeChangeCallback();
-		}
+	if (!currentThemeName) return;
+
+	const requestId = ++themeLoadRequestId;
+	try {
+		const loadedTheme = await loadTheme(currentThemeName, getCurrentThemeOptions());
+		if (requestId !== themeLoadRequestId) return;
+		theme = loadedTheme;
+	} catch {
+		if (requestId !== themeLoadRequestId) return;
+		// Fall back to dark theme
+		theme = await loadTheme("dark", getCurrentThemeOptions());
+		if (requestId !== themeLoadRequestId) return;
 	}
+	onThemeChangeCallback?.();
 }
 
 /**

package/src/modes/types.ts

@@ -58,6 +58,10 @@ export type TodoPhase = {
 	tasks: TodoItem[];
 };
 
+export interface InteractiveModeInitOptions {
+	suppressWelcomeIntro?: boolean;
+}
+
 export interface InteractiveModeContext {
 	// UI access
 	ui: TUI;
@@ -129,7 +133,8 @@ export interface InteractiveModeContext {
 	todoPhases: TodoPhase[];
 
 	// Lifecycle
-	init(): Promise<void>;
+	init(options?: InteractiveModeInitOptions): Promise<void>;
+	playWelcomeIntro(): void;
 	shutdown(): Promise<void>;
 	checkShutdownRequested(): Promise<void>;
 

package/src/modes/ultrathink.ts

@@ -1,5 +1,5 @@
 import ultrathinkNotice from "../prompts/system/ultrathink-notice.md" with { type: "text" };
-import { theme } from "./theme/theme";
+import { createGradientHighlighter } from "./gradient-highlight";
 
 /**
  * "ultrathink" keyword support, mirroring Claude Code's affordance.
@@ -11,12 +11,8 @@ import { theme } from "./theme/theme";
  * "ultrathinking"/"ultrathinks" never trigger either behavior.
  */
 
-// Cheap, stateless presence probe used to skip the boundary regex on most lines.
-const ULTRATHINK_PROBE = /ultrathink/i;
 // Detection: standalone keyword, any case. Non-global so `.test` stays stateless.
 const ULTRATHINK_WORD = /\bultrathink\b/i;
-// Highlight: global so `.replace` walks every occurrence.
-const ULTRATHINK_HIGHLIGHT = /\bultrathink\b/gi;
 
 /** Hidden system notice appended after a user message that mentions "ultrathink". */
 export const ULTRATHINK_NOTICE: string = ultrathinkNotice.trim();
@@ -26,54 +22,14 @@ export function containsUltrathink(text: string): boolean {
 	return ULTRATHINK_WORD.test(text);
 }
 
-const FG_RESET = "\x1b[39m";
-// Hue stops swept across the visible spectrum. More stops than the keyword has
-// letters so the gradient resolves smoothly regardless of casing/match length.
-const RAINBOW_STOPS = 14;
-
-let cachedMode: string | undefined;
-let cachedPalette: readonly string[] | undefined;
-
-/** Rainbow foreground escapes for the active color mode, compiled once per mode. */
-function rainbowPalette(): readonly string[] {
-	const mode = theme.getColorMode();
-	if (cachedPalette && cachedMode === mode) return cachedPalette;
-	const format = mode === "truecolor" ? "ansi-16m" : "ansi-256";
-	const palette: string[] = [];
-	for (let i = 0; i < RAINBOW_STOPS; i++) {
-		// Sweep red→violet (0..330°), stopping short of the wrap back to red.
-		const hue = Math.round((i / RAINBOW_STOPS) * 330);
-		palette.push(Bun.color(`hsl(${hue}, 90%, 62%)`, format) ?? "");
-	}
-	cachedMode = mode;
-	cachedPalette = palette;
-	return palette;
-}
-
-/** Paint each character of `word` with the next rainbow stop, resetting fg after. */
-function rainbow(word: string): string {
-	const palette = rainbowPalette();
-	const n = word.length;
-	let out = "";
-	let prev = "";
-	for (let i = 0; i < n; i++) {
-		const color = palette[Math.floor((i / n) * palette.length)] ?? palette[0] ?? "";
-		// Coalesce consecutive characters that resolve to the same stop.
-		if (color !== prev) {
-			out += color;
-			prev = color;
-		}
-		out += word[i];
-	}
-	return `${out}${FG_RESET}`;
-}
-
 /**
  * Rainbow-highlight every standalone "ultrathink" in `text` for editor display.
- * Adds only zero-width SGR escapes — the visible width is unchanged — and returns
- * the input untouched when the keyword is absent.
+ * Sweeps red→violet (hue 0..330), stopping short of the wrap back to red so the
+ * gradient resolves smoothly regardless of casing or match length.
  */
-export function highlightUltrathink(text: string): string {
-	if (!ULTRATHINK_PROBE.test(text)) return text;
-	return text.replace(ULTRATHINK_HIGHLIGHT, rainbow);
-}
+export const highlightUltrathink: (text: string) => string = createGradientHighlighter({
+	probe: /ultrathink/i,
+	highlight: /\bultrathink\b/gi,
+	stops: 14,
+	hue: t => t * 330,
+});

package/src/modes/utils/keybinding-matchers.ts

@@ -16,10 +16,21 @@ export function matchesAppInterrupt(data: string): boolean {
 	return matchesKey(data, "escape") || matchesKey(data, "esc");
 }
 
+/** Match the generic selector cancel keybinding. */
 export function matchesSelectCancel(data: string): boolean {
 	return getKeybindings().matches(data, "tui.select.cancel");
 }
 
+/** Match the generic selector up-navigation keybinding. */
+export function matchesSelectUp(data: string): boolean {
+	return getKeybindings().matches(data, "tui.select.up");
+}
+
+/** Match the generic selector down-navigation keybinding. */
+export function matchesSelectDown(data: string): boolean {
+	return getKeybindings().matches(data, "tui.select.down");
+}
+
 export function matchesAppExternalEditor(data: string): boolean {
 	const keybindings = getKeybindings();
 	const externalEditorKeys = keybindings.getKeys("app.editor.external");

package/src/prompts/system/memory-consolidation-system.md

@@ -0,0 +1,8 @@
+Summarize the memories below into 1-3 concise sentences.
+
+Preserve every fact, name, number, version, date, and decision exactly. Merge duplicates and near-duplicates; never repeat the same point. When memories conflict, state only the most recent as current. Do not invent, infer, or add anything that is not present in the memories. Output only the summary sentences, nothing else.
+
+Memories:
+{memories}
+
+Summary:

package/src/prompts/system/memory-extraction-system.md

@@ -0,0 +1,26 @@
+Extract durable, long-term memory items from the user message below.
+
+Output ONE item per line as a short plain-text statement: no JSON, no bullets, no numbering, no field labels.
+Capture only persistent, reusable information:
+- facts (name, role, employer, config, ports, versions, numbers)
+- explicit instructions to the assistant
+- stable preferences
+- dated events or deadlines
+
+Keep names, numbers, versions, and dates exact, in the message's original language. When a value is updated, output only the latest value. Ignore greetings, acknowledgements, small talk, weather, and one-off remarks.
+If nothing qualifies, output exactly: NO_FACTS
+
+Example
+Message: My name is Sam, I work at Globex, and I always use 2-space indents.
+Items:
+name is Sam
+works at Globex
+prefers 2-space indents
+
+Example
+Message: lol nice weather today, might grab a coffee later
+Items:
+NO_FACTS
+
+Message: {text}
+Items:

package/src/prompts/{commands/orchestrate.md → system/orchestrate-notice.md}

@@ -1,29 +1,17 @@
----
-name: orchestrate
-description: Drive a multi-phase task to completion via parallel subagents
----
-
-# Task
-
-$@
-
----
-
-# Orchestration Contract
-
-You are the **orchestrator** for the task above. Read it once, then execute under the rules below. The contract overrides any default tendency to yield early, narrate, or do work yourself.
+<system-notice>
+The user's message above is an **orchestration request**. Execute it as the orchestrator under the contract below. This contract overrides any default tendency to yield early, narrate, or do the work yourself.
 
 <role>
-You decompose, dispatch, verify, and iterate. You do **not** edit code. Every file mutation goes through a `task` subagent. Your tool budget is: reading for planning, `task` for dispatch, verification (`bun check`, `bun test`, `recipe`, `lsp diagnostics`), git via `bash`, and `todo_write` for tracking.
+You decompose, dispatch, verify, and iterate. You do **not** edit code. Every file mutation goes through a `task` subagent. Your tool budget is: reading for planning, `task` for dispatch, verification (`bun check`, `bun test`, `lsp diagnostics`), git via `bash`, and `todo_write` for tracking.
 </role>
 
 <rules>
 1. **Do not yield until everything is closed.** A phase finishing is *not* a yield point — launch the next phase in the same turn. Stop only when every requested item is verifiably done, or you hit a concrete [blocked] state that genuinely requires the user.
-2. **Enumerate the full surface before dispatching.** If the task references audits, plans, checklists, phase lists, or file lists, expand them into a flat set of items in `todo_write`. "Most of them" or "the important ones" is failure. Re-read the source documents — do not work from memory.
+2. **Enumerate the full surface before dispatching.** If the request references audits, plans, checklists, phase lists, or file lists, expand them into a flat set of items in `todo_write`. "Most of them" or "the important ones" is failure. Re-read the source documents — do not work from memory.
 3. **Parallelize maximally.** Every set of edits with disjoint file scope MUST ship as one `task` batch. Serialize only when one subagent produces a contract (types, schema, shared module) the next consumes — and state the dependency when you do.
 4. **Each `task` assignment is self-contained.** Subagents have no shared context. Spell out: target files (≤3–5 explicit paths, no globs), the change with APIs and patterns, edge cases, and observable acceptance criteria. Do not assume they read the same plan you did.
 5. **Verify after every phase before launching the next.** Run the appropriate gate: `bun check` for types, package-scoped `bun test` for behavior, `lsp diagnostics` for changed files. If a phase introduced breakage, dispatch fix-up subagents *before* moving on. Never declare a phase done on a red tree.
-6. **Commit policy.** If the task asks for commits or the repo workflow expects them, commit after each green phase with a focused message. Never commit a red tree. Never commit work the user did not ask to commit.
+6. **Commit policy.** If the request asks for commits or the repo workflow expects them, commit after each green phase with a focused message. Never commit a red tree. Never commit work the user did not ask to commit.
 7. **Respawn, do not absorb.** If a subagent returns incomplete or wrong work, spawn a corrective subagent with the specific gap — do not silently fix it yourself.
 8. **No scope creep, no scope shrink.** Do not add work the user did not ask for. Do not relabel unfinished items as "follow-up", "v1", or "MVP" to imply completion.
 9. **Subagents do not verify, lint, or format.** Every `task` assignment MUST instruct the subagent to skip all gates and formatters. Their job is the edit only. You — the orchestrator — run verification and formatting **once** at the end of the phase across the union of changed files. Avoids redundant runs and racing formatter passes.
@@ -47,3 +35,4 @@ You decompose, dispatch, verify, and iterate. You do **not** edit code. Every fi
 - Marking todos done based on subagent self-reports without verifying the gate.
 - Summarizing progress in chat instead of advancing to the next phase.
 </anti-patterns>
+</system-notice>

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

@@ -54,7 +54,9 @@ With most FS/bash-like tools, static references to them will automatically resol
 - `skill://<name>`: Skill instructions
    - `/<path>`: File within a skill
 - `rule://<name>`: Rule details
+{{#if hasMemoryRoot}}
 - `memory://root`: Project memory summary
+{{/if}}
 - `agent://<id>`: Full agent output artifact
    - `/<path>`: JSON field extraction
 - `artifact://<id>`: Artifact content

package/src/prompts/system/tiny-title-system.md

@@ -0,0 +1,8 @@
+You generate concise terminal session titles.
+
+Input is one user message inside `<user-message>` tags.
+
+Return one specific 3-6 word title.
+Continue the assistant response after `<title>` and close it with `</title>`.
+
+NEVER include quotes, punctuation, markdown, commentary, or a second line.

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

@@ -0,0 +1,8 @@
+Edit Mnemosyne long-term memories by id.
+
+Use only with ids returned by the `recall` tool. Operations:
+- `update`: replace content and/or importance for a working memory.
+- `forget`: permanently delete a working memory.
+- `invalidate`: softly supersede a working or episodic memory, optionally pointing at `replacement_id`.
+
+Prefer `invalidate` when a memory became stale but its history may still be useful. Use `forget` only for content that should be hard-deleted.

package/src/prompts/tools/read.md

@@ -46,7 +46,11 @@ Extracts text from PDF, Word, PowerPoint, Excel, RTF, and EPUB. Notebooks (`.ipy
 
 # Images
 
+{{#if INSPECT_IMAGE_ENABLED}}
 Reading an image path returns metadata (mime, bytes, dimensions, channels, alpha). For actual visual analysis, call `inspect_image` with the path and a question describing what to inspect.
+{{else}}
+Reading an image path returns the decoded image inline (PNG, JPEG, GIF, WEBP) for direct visual analysis.
+{{/if}}
 
 # Archives
 

package/src/prompts/tools/task.md

@@ -30,15 +30,12 @@ Subagents have no conversation history. Every fact, file path, and direction the
 </parameters>
 
 <rules>
+- **Maximize batch width.** Spawn the widest parallel set the work decomposes into. NEVER spawn a single-task batch for divisible work, or defer work that could have been concurrent.
 - NEVER assign tasks to run project-wide build/test/lint. Caller verifies after the batch.
 - **Subagents do not verify, lint, or format.** Every assignment MUST instruct the subagent to skip all gates and formatters. You run them once at the end across the union of changed files — avoids redundant runs and racing formatter passes.
-{{#if ircEnabled}}
-- Each task: ≤3–5 explicit files. Overlapping file sets are tolerable when peers can coordinate via `irc`, but still fan out to a cluster when the scopes are cleanly separable.
-- No globs, no "update all", no package-wide scope.
-{{else}}
-- Each task: ≤3–5 explicit files. No globs, no "update all", no package-wide scope. Fan out to a cluster instead.
-{{/if}}
-- Pass large payloads via `local://<path>` URIs, not inline.
+- No globs, no "update all", no package-wide scope. Fan out.
+- Do not concern yourself with how agents might overlap on certain actions. Never use it as an excuse to go slower: they can resolve collisions in real-time with the harness facilities.
+- Pass large payloads via `local://<path>` URIs, not inline. {{#if contextEnabled}} (other than the context){{/if}}
 {{#if contextEnabled}}- Put shared constraints in `context` once; do not duplicate across assignments.{{/if}}
 - Prefer agents that investigate **and** edit in one pass; only spin a read-only discovery step when affected files are genuinely unknown.
 </rules>