@oh-my-pi/pi-coding-agent 14.7.3 → 14.7.5

package/src/edit/streaming.ts

@@ -16,7 +16,13 @@ import type { Theme } from "../modes/theme/theme";
 import { type EditMode, resolveEditMode } from "../utils/edit-mode";
 import { computeEditDiff, type DiffError, type DiffResult } from "./diff";
 import { type ApplyPatchEntry, expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
-import { computeHashlineDiff } from "./modes/hashline";
+import {
+	computeHashlineDiff,
+	computeHashlineSectionDiff,
+	containsRecognizableHashlineOperations,
+	type HashlineInputSection,
+	splitHashlineInputs,
+} from "./modes/hashline";
 import { computePatchDiff, type PatchEditEntry } from "./modes/patch";
 import type { ReplaceEditEntry } from "./modes/replace";
 
@@ -223,12 +229,48 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 	async computeDiffPreview(args, ctx) {
 		if (typeof args.input !== "string" || args.input.length === 0) return null;
 		ctx.signal.throwIfAborted();
-		const result = await computeHashlineDiff({ input: args.input, path: args.path }, ctx.cwd, {
-			autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
-		});
-		ctx.signal.throwIfAborted();
-		if ("error" in result && !args.path) return [{ path: "", error: result.error }];
-		return [toPerFilePreview(args.path ?? "", result)];
+
+		let sections: HashlineInputSection[];
+		try {
+			sections = splitHashlineInputs(args.input, { cwd: ctx.cwd, path: args.path });
+		} catch {
+			// Single-section fallback keeps the original error rendering for the
+			// "haven't typed `@PATH` yet" case.
+			const result = await computeHashlineDiff({ input: args.input, path: args.path }, ctx.cwd, {
+				autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
+			});
+			ctx.signal.throwIfAborted();
+			if ("error" in result && !args.path) return [{ path: "", error: result.error }];
+			return [toPerFilePreview(args.path ?? "", result)];
+		}
+		if (sections.length === 0) return null;
+
+		// While the trailing section is still being typed (no operations yet)
+		// skip it so its empty/parse-error result doesn't replace previews of
+		// already-completed sections with an opaque header.
+		const lastIndex = sections.length - 1;
+		const trailingIncomplete =
+			sections.length > 1 && !containsRecognizableHashlineOperations(sections[lastIndex].diff);
+		const sectionsToProcess = trailingIncomplete ? sections.slice(0, -1) : sections;
+		const trailingProcessedIndex = sectionsToProcess.length - 1;
+
+		const previews: PerFileDiffPreview[] = [];
+		for (let i = 0; i < sectionsToProcess.length; i++) {
+			ctx.signal.throwIfAborted();
+			const section = sectionsToProcess[i];
+			const result = await computeHashlineSectionDiff(section, ctx.cwd, {
+				autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
+			});
+			ctx.signal.throwIfAborted();
+			// In a multi-section preview, ignore parse/apply errors from the
+			// last section: it's still streaming and the partial op may not
+			// parse yet. Earlier sections are stable and stay rendered.
+			if (sectionsToProcess.length > 1 && i === trailingProcessedIndex && "error" in result) {
+				continue;
+			}
+			previews.push(toPerFilePreview(section.path, result));
+		}
+		return previews.length > 0 ? previews : null;
 	},
 	renderStreamingFallback() {
 		return "";

package/src/modes/components/diff.ts

@@ -1,7 +1,7 @@
 import { sanitizeText } from "@oh-my-pi/pi-natives";
 import { getIndentation } from "@oh-my-pi/pi-utils";
 import * as Diff from "diff";
-import { theme } from "../../modes/theme/theme";
+import { getLanguageFromPath, highlightCode, theme } from "../../modes/theme/theme";
 import { type CodeFrameMarker, formatCodeFrameLine, replaceTabs } from "../../tools/render-utils";
 
 /** SGR dim on / normal intensity — additive, preserves fg/bg colors. */
@@ -115,6 +115,10 @@ export function renderDiff(diffText: string, options: RenderDiffOptions = {}): s
 		return Math.max(width, lineNumber.length);
 	}, 0);
 
+	// Batch-highlight context (unedited) lines so consecutive lines tokenize
+	// with full multi-line context. Highlighting is a no-op when no language
+	// can be detected from the file path.
+	const contextHighlights = highlightContextLines(parsedLines, options.filePath);
 	// Track the line number rendered on the previous emitted line so we can
 	// blank out duplicate gutters. Two cases trigger this:
 	//  1. Single-line replacement (`-N` followed by `+N`) — the `+N` repeats `N`.
@@ -206,15 +210,58 @@ export function renderDiff(diffText: string, options: RenderDiffOptions = {}): s
 			);
 			i++;
 		} else {
-			result.push(
-				theme.fg(
-					"toolDiffContext",
-					formatLine(" ", parsed.lineNum, visualizeIndent(parsed.content, options.filePath)),
-				),
-			);
+			const highlighted = contextHighlights.get(i);
+			const content =
+				highlighted !== undefined
+					? replaceTabs(highlighted, options.filePath)
+					: visualizeIndent(parsed.content, options.filePath);
+			result.push(theme.fg("toolDiffContext", formatLine(" ", parsed.lineNum, content)));
 			i++;
 		}
 	}
 
 	return result.join("\n");
 }
+
+/**
+ * Batch-highlight runs of consecutive context lines.
+ * Returns a map keyed by index in `parsedLines` to the highlighted content
+ * for that line. Lines whose language is unknown are not added to the map,
+ * letting callers fall back to the existing rendering path.
+ */
+function highlightContextLines(
+	parsedLines: Array<{ prefix: CodeFrameMarker; lineNum: string; content: string } | null>,
+	filePath: string | undefined,
+): Map<number, string> {
+	const map = new Map<number, string>();
+	const lang = filePath ? getLanguageFromPath(filePath) : undefined;
+	if (!lang) return map;
+
+	let runIndices: number[] = [];
+	let runContents: string[] = [];
+	const flush = () => {
+		if (runContents.length === 0) return;
+		const highlighted = highlightCode(runContents.join("\n"), lang);
+		for (let k = 0; k < runIndices.length; k++) {
+			map.set(runIndices[k], highlighted[k] ?? runContents[k]);
+		}
+		runIndices = [];
+		runContents = [];
+	};
+
+	for (let j = 0; j < parsedLines.length; j++) {
+		const p = parsedLines[j];
+		// Collapse markers ("...") are emitted as context lines but are not real
+		// code; highlighting them produces nonsense (e.g. "..." → spread operator)
+		// and would also stitch together unrelated context blocks across the gap.
+		const isCollapseMarker = p?.prefix === " " && (p.content === "..." || p.content === "…");
+		if (p && p.prefix === " " && !isCollapseMarker) {
+			runIndices.push(j);
+			runContents.push(p.content);
+		} else {
+			flush();
+		}
+	}
+	flush();
+	return map;
+}

package/src/modes/interactive-mode.ts

@@ -73,6 +73,15 @@ import { MCPCommandController } from "./controllers/mcp-command-controller";
 import { SelectorController } from "./controllers/selector-controller";
 import { SSHCommandController } from "./controllers/ssh-command-controller";
 import { TodoCommandController } from "./controllers/todo-command-controller";
+import {
+	consumeLoopLimitIteration,
+	createLoopLimitRuntime,
+	describeLoopLimit,
+	describeLoopLimitRuntime,
+	isLoopDurationExpired,
+	type LoopLimitRuntime,
+	parseLoopLimitArgs,
+} from "./loop-limit";
 import { OAuthManualInputManager } from "./oauth-manual-input";
 import { SessionObserverRegistry } from "./session-observer-registry";
 import type { Theme } from "./theme/theme";
@@ -158,6 +167,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	planModePlanFilePath: string | undefined = undefined;
 	loopModeEnabled = false;
 	loopPrompt: string | undefined = undefined;
+	loopLimit: LoopLimitRuntime | undefined = undefined;
 	#loopAutoSubmitTimer: NodeJS.Timeout | undefined;
 	todoPhases: TodoPhase[] = [];
 	hideThinkingBlock = false;
@@ -535,25 +545,35 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	async #runLoopIteration(action: "prompt" | "compact" | "reset", prompt: string): Promise<void> {
+		if (!consumeLoopLimitIteration(this.loopLimit)) {
+			this.disableLoopMode("Loop limit reached. Loop mode disabled.");
+			return;
+		}
+
 		if (action === "compact") {
 			await this.handleCompactCommand();
 		} else if (action === "reset") {
 			await this.handleClearCommand();
 		}
 		if (!this.loopModeEnabled || !this.onInputCallback) return;
+		if (isLoopDurationExpired(this.loopLimit)) {
+			this.disableLoopMode("Loop time limit reached. Loop mode disabled.");
+			return;
+		}
 		this.onInputCallback(this.startPendingSubmission({ text: prompt }));
 	}
 
-	disableLoopMode(): void {
+	disableLoopMode(message = "Loop mode disabled."): void {
 		const wasEnabled = this.loopModeEnabled;
 		this.loopModeEnabled = false;
 		this.loopPrompt = undefined;
+		this.loopLimit = undefined;
 		this.#cancelLoopAutoSubmit();
 		this.statusLine.setLoopModeStatus(undefined);
 		this.updateEditorTopBorder();
 		this.ui.requestRender();
 		if (wasEnabled) {
-			this.showStatus("Loop mode disabled.");
+			this.showStatus(message);
 		}
 	}
 
@@ -567,18 +587,26 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#cancelLoopAutoSubmit();
 	}
 
-	async handleLoopCommand(): Promise<void> {
+	async handleLoopCommand(args = ""): Promise<void> {
 		if (this.loopModeEnabled) {
 			this.disableLoopMode();
 			return;
 		}
+		const parsedLimit = parseLoopLimitArgs(args);
+		if (typeof parsedLimit === "string") {
+			this.showError(parsedLimit);
+			return;
+		}
 		this.loopModeEnabled = true;
 		this.loopPrompt = undefined;
+		this.loopLimit = createLoopLimitRuntime(parsedLimit);
 		this.statusLine.setLoopModeStatus({ enabled: true });
 		this.updateEditorTopBorder();
 		this.ui.requestRender();
+		const limitSuffix = parsedLimit ? ` Limited to ${describeLoopLimit(parsedLimit)}.` : "";
+		const remainingSuffix = this.loopLimit ? ` ${describeLoopLimitRuntime(this.loopLimit)}.` : "";
 		this.showStatus(
-			"Loop mode enabled. Your next prompt will repeat after each turn. Esc cancels the current iteration; /loop again to disable.",
+			`Loop mode enabled.${limitSuffix}${remainingSuffix} Your next prompt will repeat after each turn. Esc cancels the current iteration; /loop again to disable.`,
 		);
 	}
 

package/src/modes/loop-limit.ts

@@ -0,0 +1,140 @@
+export type LoopLimitConfig =
+	| {
+			kind: "iterations";
+			iterations: number;
+	  }
+	| {
+			kind: "duration";
+			durationMs: number;
+	  };
+
+export type LoopLimitRuntime =
+	| {
+			kind: "iterations";
+			initial: number;
+			remaining: number;
+	  }
+	| {
+			kind: "duration";
+			durationMs: number;
+			deadlineMs: number;
+	  };
+
+const TIME_UNITS_MS = new Map<string, number>([
+	["s", 1_000],
+	["sec", 1_000],
+	["secs", 1_000],
+	["second", 1_000],
+	["seconds", 1_000],
+	["m", 60_000],
+	["min", 60_000],
+	["mins", 60_000],
+	["minute", 60_000],
+	["minutes", 60_000],
+	["h", 3_600_000],
+	["hr", 3_600_000],
+	["hrs", 3_600_000],
+	["hour", 3_600_000],
+	["hours", 3_600_000],
+]);
+
+export function parseLoopLimitArgs(args: string): LoopLimitConfig | undefined | string {
+	const trimmed = args.trim().toLowerCase();
+	if (!trimmed) return undefined;
+
+	const parts = trimmed.split(/\s+/);
+	if (parts.length > 2) {
+		return "Usage: /loop [count|duration]. Examples: /loop 10, /loop 10m, /loop 10min.";
+	}
+
+	if (parts.length === 2) {
+		return parseDurationParts(parts[0], parts[1]);
+	}
+
+	const token = parts[0];
+	const iterationMatch = /^(\d+)$/.exec(token);
+	if (iterationMatch) {
+		const iterations = Number(iterationMatch[1]);
+		if (!Number.isSafeInteger(iterations) || iterations <= 0) {
+			return "Loop count must be a positive integer.";
+		}
+		return { kind: "iterations", iterations };
+	}
+
+	const durationMatch = /^(\d+)([a-z]+)$/.exec(token);
+	if (durationMatch) {
+		return parseDurationParts(durationMatch[1], durationMatch[2]);
+	}
+
+	return "Usage: /loop [count|duration]. Examples: /loop 10, /loop 10m, /loop 10min.";
+}
+
+function parseDurationParts(amountText: string, unitText: string): LoopLimitConfig | string {
+	if (!/^\d+$/.test(amountText)) {
+		return "Loop duration must use a positive integer amount.";
+	}
+
+	const amount = Number(amountText);
+	if (!Number.isSafeInteger(amount) || amount <= 0) {
+		return "Loop duration must be positive.";
+	}
+
+	const unitMs = TIME_UNITS_MS.get(unitText);
+	if (unitMs === undefined) {
+		return "Loop duration unit must be seconds, minutes, or hours.";
+	}
+
+	return { kind: "duration", durationMs: amount * unitMs };
+}
+
+export function createLoopLimitRuntime(
+	config: LoopLimitConfig | undefined,
+	nowMs = Date.now(),
+): LoopLimitRuntime | undefined {
+	if (!config) return undefined;
+	if (config.kind === "iterations") {
+		return { kind: "iterations", initial: config.iterations, remaining: config.iterations };
+	}
+	return { kind: "duration", durationMs: config.durationMs, deadlineMs: nowMs + config.durationMs };
+}
+
+export function consumeLoopLimitIteration(limit: LoopLimitRuntime | undefined, nowMs = Date.now()): boolean {
+	if (!limit) return true;
+	if (limit.kind === "duration") {
+		return nowMs < limit.deadlineMs;
+	}
+	if (limit.remaining <= 0) return false;
+	limit.remaining -= 1;
+	return true;
+}
+
+export function isLoopDurationExpired(limit: LoopLimitRuntime | undefined, nowMs = Date.now()): boolean {
+	return limit?.kind === "duration" && nowMs >= limit.deadlineMs;
+}
+
+export function describeLoopLimit(config: LoopLimitConfig): string {
+	if (config.kind === "iterations") {
+		return `${config.iterations} ${config.iterations === 1 ? "iteration" : "iterations"}`;
+	}
+	return formatDuration(config.durationMs);
+}
+
+export function describeLoopLimitRuntime(limit: LoopLimitRuntime): string {
+	if (limit.kind === "iterations") {
+		return `${limit.remaining} of ${limit.initial} ${limit.initial === 1 ? "iteration" : "iterations"} remaining`;
+	}
+	return `${formatDuration(limit.durationMs)} limit`;
+}
+
+function formatDuration(durationMs: number): string {
+	if (durationMs % 3_600_000 === 0) {
+		const hours = durationMs / 3_600_000;
+		return `${hours} ${hours === 1 ? "hour" : "hours"}`;
+	}
+	if (durationMs % 60_000 === 0) {
+		const minutes = durationMs / 60_000;
+		return `${minutes} ${minutes === 1 ? "minute" : "minutes"}`;
+	}
+	const seconds = durationMs / 1_000;
+	return `${seconds} ${seconds === 1 ? "second" : "seconds"}`;
+}

package/src/modes/types.ts

@@ -24,6 +24,7 @@ import type { HookInputComponent } from "./components/hook-input";
 import type { HookSelectorComponent } from "./components/hook-selector";
 import type { StatusLineComponent } from "./components/status-line";
 import type { ToolExecutionHandle } from "./components/tool-execution";
+import type { LoopLimitRuntime } from "./loop-limit";
 import type { OAuthManualInputManager } from "./oauth-manual-input";
 import type { Theme } from "./theme/theme";
 
@@ -86,6 +87,7 @@ export interface InteractiveModeContext {
 	planModeEnabled: boolean;
 	loopModeEnabled: boolean;
 	loopPrompt?: string;
+	loopLimit?: LoopLimitRuntime;
 	planModePlanFilePath?: string;
 	hideThinkingBlock: boolean;
 	pendingImages: ImageContent[];
@@ -248,7 +250,7 @@ export interface InteractiveModeContext {
 	openExternalEditor(): void;
 	registerExtensionShortcuts(): void;
 	handlePlanModeCommand(initialPrompt?: string): Promise<void>;
-	handleLoopCommand(): Promise<void>;
+	handleLoopCommand(args?: string): Promise<void>;
 	disableLoopMode(): void;
 	pauseLoop(): void;
 	handleExitPlanModeTool(details: ExitPlanModeDetails): Promise<void>;

package/src/prompts/agents/designer.md

@@ -4,8 +4,7 @@ description: UI/UX specialist for design implementation, review, visual refineme
 model: pi/designer
 ---
 
-You are an expert UI/UX designer implementing and reviewing UI designs.
-You **MAY** make file edits, create components, and run commands—and **SHOULD** do so when needed.
+Implement and review UI designs. Edit files, create components, run commands when needed.
 
 <strengths>
 - Translate design intent into working UI code

package/src/prompts/agents/explore.md

@@ -29,13 +29,11 @@ output:
       type: string
 ---
 
-You are a file search specialist and a codebase scout.
-
-Given a task, you rapidly investigate the codebase and return structured findings another agent can use without re-reading everything.
+Investigate the codebase rapidly. Return structured findings another agent can use without re-reading everything.
 
 <directives>
 - You **MUST** use tools for broad pattern matching / code search as much as possible.
-- You **SHOULD** invoke tools in parallel when possible—this is a short investigation, and you are supposed to finish in a few seconds.
+- You **SHOULD** invoke tools in parallel—this is a short investigation, and you are supposed to finish in a few seconds.
 - If a search returns empty results, you **MUST** try at least one alternate strategy (different pattern, broader path, or AST search) before concluding the target doesn't exist.
 </directives>
 
@@ -47,7 +45,6 @@ You **MUST** infer the thoroughness from the task; default to medium:
 </thoroughness>
 
 <procedure>
-You **SHOULD** generally follow this procedure, but are allowed to adjust it as the task requires:
 1. Locate relevant code using tools.
 2. Read key sections (You **MUST NOT** read full files unless they're tiny)
 3. Identify types/interfaces/key functions.

package/src/prompts/agents/init.md

@@ -4,12 +4,9 @@ description: Generate AGENTS.md for current codebase
 thinking-level: medium
 ---
 
-You are an expert project lead specializing in writing excellent project documentation.
-
-You **MUST** launch multiple `explore` agents in parallel (via `task` tool) scanning different areas (core src, tests, configs/build, scripts/docs), then synthesize your findings into a detailed AGENTS.md file.
+Generate AGENTS.md by launching multiple `explore` agents in parallel (via `task` tool) scanning different areas (core src, tests, configs/build, scripts/docs), then synthesize findings into a single file.
 
 <structure>
-You will likely need to document these sections, but only take it as a starting point and adjust it to the specific codebase:
 - **Project Overview**: Brief description of project purpose
 - **Architecture & Data Flow**: High-level structure, key modules, data flow
 - **Key Directories**: Main source directories, purposes

package/src/prompts/agents/librarian.md

@@ -65,7 +65,7 @@ output:
         type: string
 ---
 
-You are a library research specialist. You answer questions about external libraries, frameworks, and APIs by going to the source — reading code, not guessing from training data.
+Answer questions about external libraries, frameworks, and APIs by reading source code and official documentation.
 
 <critical>
 You **MUST** ground every claim in source code or official documentation. You **MUST NOT** rely on training data for API details — it may be stale or wrong.
@@ -74,8 +74,6 @@ You **MUST** operate as read-only on the user's project. You **MUST NOT** modify
 
 <procedure>
 ## 1. Classify the request
-
-Before acting, determine what kind of question this is:
 - **Conceptual**: "How do I use X?", "Best practice for Y?" — Prioritize types, docs, and usage examples.
 - **Implementation**: "How does X implement Y?", "Show me the source of Z" — Clone and read the actual code.
 - **Behavioral**: "Why does X behave this way?", "What's the default for Y?" — Read implementation, find where values are set, check tests.

package/src/prompts/agents/plan.md

@@ -7,7 +7,7 @@ model: pi/plan, pi/slow
 thinking-level: high
 ---
 
-You are an expert software architect analyzing the codebase and the user's request, and producing a detailed plan for the implementation.
+Analyze the codebase and the user's request. Produce a detailed implementation plan.
 
 ## Phase 1: Understand
 1. Parse requirements precisely
@@ -33,14 +33,13 @@ You **MUST** spawn `explore` agents for independent areas and synthesize finding
 
 You **MUST** write a plan executable without re-exploration.
 
-You will likely need to document these sections, but only take it as a starting point and adjust it to the specific request.
 <structure>
-**Summary**: What to build and why (one paragraph).
-**Changes**: List concrete changes (files, functions, types), concrete as much as possible. Exact file paths/line ranges where relevant.
-**Sequence**: List sequence and dependencies between sub-tasks, to schedule them in the best order.
-**Edge Cases**: List edge cases and error conditions, to be aware of.
-**Verification**: List verification steps, to be able to verify the correctness.
-**Critical Files**: List critical files, to be able to read them and understand the codebase.
+- **Summary**: What to build and why (one paragraph).
+- **Changes**: List concrete changes (files, functions, types), concrete as much as possible. Exact file paths/line ranges where relevant.
+- **Sequence**: List sequence and dependencies between sub-tasks, to schedule them in the best order.
+- **Edge Cases**: List edge cases and error conditions, to be aware of.
+- **Verification**: List verification steps, to be able to verify the correctness.
+- **Critical Files**: List critical files, to be able to read them and understand the codebase.
 </structure>
 
 <critical>

package/src/prompts/agents/reviewer.md

@@ -56,8 +56,7 @@ output:
             type: number
 ---
 
-You are an expert software engineer reviewing proposed changes.
-Your goal is to identify bugs the author would want fixed before merge.
+Identify bugs the author would want fixed before merge.
 
 <procedure>
 1. Run `git diff` (or `gh pr diff <number>`) to view patch

package/src/prompts/ci-green-request.md

@@ -4,24 +4,24 @@ Do not stop after a single fix attempt.
 </critical>
 
 <instruction>
-- Prefer the `github` tool with `op: run_watch` and no other arguments if that tool is available.
+- Prefer `github` tool with `op: run_watch` and no other arguments if available.
 - Otherwise use `gh` cli.
-- Use the workflow runs for the current HEAD commit as the source of truth after each push.
+- Use workflow runs for current HEAD as source of truth after each push.
 </instruction>
 
 <procedure>
-1. Watch the workflow runs for the current HEAD commit.
-2. If any run fails, inspect the failing job output and logs.
-3. Identify the root cause and make the minimal correct fix.
-4. Run local verification when it materially reduces the chance of another failing push.
+1. Watch workflow runs for current HEAD commit.
+2. If any run fails, inspect failing job output and logs.
+3. Identify root cause and make minimal correct fix.
+4. Run local verification if it reduces chance of another failing push.
 5. Push the branch.
-6. Watch the workflow runs for the new HEAD commit again.
-7. Repeat until the workflow runs for the latest HEAD commit succeed.
+6. Watch workflow runs for new HEAD commit again.
+7. Repeat until workflow runs for latest HEAD commit succeed.
 </procedure>
 
 <caution>
-- Treat each new push as a fresh CI attempt and re-watch the new HEAD commit immediately.
-- If the watcher output is not sufficient, inspect the underlying workflow or job context before changing code.
+- Treat each push as fresh CI attempt. Re-watch new HEAD immediately.
+- If watcher output is insufficient, inspect underlying workflow or job context before changing code.
 </caution>
 
 {{#if headTag}}

package/src/prompts/commands/orchestrate.md

@@ -0,0 +1,48 @@
+---
+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.
+
+<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.
+</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.
+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.
+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.
+</rules>
+
+<workflow>
+1. **Ingest.** Read every referenced file (audits, plans, prior agent output, current branch state). Run `git status` to see uncommitted changes.
+2. **Plan.** Materialize the full work surface in `todo_write` as ordered phases. Within each phase, list the parallelizable units.
+3. **Dispatch phase.** Launch all parallel `task` subagents in one call. Wait for the batch.
+4. **Verify phase.** Run the gates. On failure, dispatch fix-up subagents and re-verify. Do not advance with a red gate.
+5. **Commit phase** (if applicable). Focused message naming the phase.
+6. **Advance.** Mark the phase done in `todo_write`, immediately start the next phase. No summary message between phases — keep going.
+7. **Final verification.** When the last phase is green, run the full gate set once more and confirm every `todo_write` item is closed. Then yield with a terse status, not a recap.
+</workflow>
+
+<anti-patterns>
+- Editing files yourself "because it's faster".
+- Yielding after phase 1 with "ready to continue?".
+- Dispatching one subagent at a time when five could run in parallel.
+- Skipping `bun check` between phases because "the change looked safe".
+- 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>

package/src/prompts/memories/consolidation.md

@@ -1,4 +1,4 @@
-You are the memory consolidation agent.
+Memory consolidation agent.
 Memory root: memory://root
 Input corpus (raw memories):
 {{raw_memories}}
@@ -19,12 +19,12 @@ Produce strict JSON only with this schema — you **MUST NOT** include any other
   ]
 }
 Requirements:
-- memory_md: full long-term memory document, curated and readable.
-- memory_summary: compact prompt-time memory guidance.
-- skills: reusable procedural playbooks. Empty array allowed.
-- Each skill.name maps to skills/<name>/.
-- Each skill.content maps to skills/<name>/SKILL.md.
-- scripts/templates/examples are optional. When present, each entry **MUST** write to skills/<name>/<bucket>/<path>.
-- You **MUST** only include files worth keeping long-term; you **MUST** omit stale assets so they are pruned.
-- You **MUST** preserve useful prior themes; you **MUST** remove stale or contradictory guidance.
-- You **MUST** treat memory as advisory: current repository state wins.
+- memory_md: long-term memory document.
+- memory_summary: prompt-time memory guidance.
+- skills: reusable playbooks. Empty array allowed.
+- skill.name maps to skills/<name>/.
+- skill.content maps to skills/<name>/SKILL.md.
+- scripts/templates/examples: optional. Each entry **MUST** write to skills/<name>/<bucket>/<path>.
+- Only include files worth keeping long-term. Omit stale assets so they are pruned.
+- Preserve useful prior themes. Remove stale or contradictory guidance.
+- Treat memory as advisory: current repository state wins.

package/src/prompts/memories/read-path.md

@@ -1,11 +1,11 @@
 # Memory Guidance
 Memory root: memory://root
 Operational rules:
-1) You **MUST** read `memory://root/memory_summary.md` first.
-2) If needed, you **SHOULD** inspect `memory://root/MEMORY.md` and `memory://root/skills/<name>/SKILL.md`.
-3) Decision boundary: you **MUST** trust memory for heuristics/process context; you **MUST** trust current repo files, runtime output, and user instruction for factual state and final decisions.
-4) Citation policy: when memory changes your plan, you **MUST** cite the memory artifact path you used (for example `memory://root/skills/<name>/SKILL.md`) and pair it with current-repo evidence before acting.
-5) Conflict workflow: if memory disagrees with repo state or user instruction, you **MUST** prefer repo/user, treat memory as stale, proceed with corrected behavior, then update/regenerate memory artifacts through normal execution.
-6) You **MUST** escalate confidence only after repository verification; memory alone **MUST NOT** be treated as sufficient proof.
+1) Read `memory://root/memory_summary.md` first.
+2) If needed, inspect `memory://root/MEMORY.md` and `memory://root/skills/<name>/SKILL.md`.
+3) Trust memory for heuristics and process context. Trust current repo files, runtime output, and user instruction for factual state and final decisions.
+4) When memory changes your plan, cite the artifact path (e.g. `memory://root/skills/<name>/SKILL.md`) and pair it with current-repo evidence.
+5) If memory disagrees with repo state or user instruction, prefer repo/user. Treat memory as stale. Proceed with corrected behavior, then update/regenerate memory artifacts.
+6) Escalate confidence only after repository verification. Memory alone **MUST NOT** be treated as sufficient proof.
 Memory summary:
 {{memory_summary}}