@oh-my-pi/pi-coding-agent 16.2.2 → 16.2.3

package/src/modes/interactive-mode.ts

@@ -112,6 +112,7 @@ import { renderTreeList } from "../tui/tree-list";
 import type { EventBus } from "../utils/event-bus";
 import { getEditorCommand, openInEditor } from "../utils/external-editor";
 import { getSessionAccentAnsi, getSessionAccentHex } from "../utils/session-color";
+import { messageHasDisplayableThinking } from "../utils/thinking-display";
 import { popTerminalTitle, pushTerminalTitle, setSessionTerminalTitle } from "../utils/title-generator";
 import {
 	isSearchProviderId,
@@ -413,14 +414,29 @@ export class InteractiveMode implements InteractiveModeContext {
 	#modelCycleClearTimer: NodeJS.Timeout | undefined;
 	todoPhases: TodoPhase[] = [];
 	hideThinkingBlock = false;
+	#sessionsWithDisplayableThinkingContent = new WeakSet<AgentSession>();
+	/** Whether the visible session has produced thinking content the user can reveal. */
+	get hasDisplayableThinkingContent(): boolean {
+		return this.#sessionsWithDisplayableThinkingContent.has(this.viewSession);
+	}
+	/** Record received reasoning content so Ctrl+T can reveal it even when model metadata says thinking is off. */
+	noteDisplayableThinkingContent(message: AgentMessage): boolean {
+		if (this.hasDisplayableThinkingContent || !messageHasDisplayableThinking(message, this.proseOnlyThinking)) {
+			return false;
+		}
+		this.#sessionsWithDisplayableThinkingContent.add(this.viewSession);
+		return true;
+	}
 	/**
-	 * Effective thinking-block visibility: hidden when the user's setting is on
-	 * OR the session thinking level is "off". Some providers (MiniMax, GLM,
-	 * DeepSeek) return thinking blocks even with reasoning disabled; this
-	 * respects the user's intent when they set thinking to "off" (#626).
+	 * Effective thinking-block visibility: hidden when the user's setting is on,
+	 * or while thinking is "off" before the session has actually produced
+	 * displayable thinking content. Some providers return thinking blocks without
+	 * advertising reasoning support, so observed content unlocks the visibility
+	 * toggle.
 	 */
 	get effectiveHideThinkingBlock(): boolean {
-		return this.hideThinkingBlock || (this.viewSession?.thinkingLevel ?? ThinkingLevel.Off) === ThinkingLevel.Off;
+		const thinkingOff = (this.viewSession?.thinkingLevel ?? ThinkingLevel.Off) === ThinkingLevel.Off;
+		return this.hideThinkingBlock || (thinkingOff && !this.hasDisplayableThinkingContent);
 	}
 	proseOnlyThinking = true;
 	compactionQueuedMessages: CompactionQueuedMessage[] = [];
@@ -1417,6 +1433,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			sessionAccent: settings.get("statusLine.sessionAccent"),
 			transparent: settings.get("statusLine.transparent"),
 			segmentOptions: settings.get("statusLine.segmentOptions"),
+			compactThinkingLevel: settings.get("statusLine.compactThinkingLevel"),
 		});
 	}
 
@@ -1478,11 +1495,47 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	rebuildChatFromMessages(): void {
+		// Mid-stream rebuilds (e.g. `/shake`, theme/setting changes that touch the
+		// transcript) replay only committed `state.messages`. The agent's in-flight
+		// `streamMessage` and its still-pending tool calls live OUTSIDE
+		// `state.messages` until `message_end`, so a plain clear+replay detaches
+		// their UI components while keeping the `streamingComponent` / `pendingTools`
+		// references — subsequent `message_update`/`message_end` events would then
+		// update orphaned components that never re-render and the live LLM output
+		// vanishes from the chat (#3656). Snapshot the in-flight components,
+		// clear+replay, then re-append them in their original chat-container order
+		// and restore the `pendingTools` map so streaming routes back into them.
+		const liveComponents: Component[] = [];
+		const livePendingTools = new Map<string, ToolExecutionHandle>();
+		if (this.viewSession?.isStreaming) {
+			const liveSet = new Set<Component>();
+			if (this.streamingComponent) liveSet.add(this.streamingComponent);
+			for (const [id, component] of this.pendingTools) {
+				livePendingTools.set(id, component);
+				liveSet.add(component as unknown as Component);
+			}
+			if (liveSet.size > 0) {
+				for (const child of this.chatContainer.children) {
+					if (liveSet.has(child)) liveComponents.push(child);
+				}
+			}
+		}
 		this.chatContainer.clear();
 		// Live display uses the compacted transcript tail; export/resume callers
 		// can still request the full inline compaction history.
 		const context = this.viewSession.buildTranscriptSessionContext({ collapseCompactedHistory: true });
 		this.renderSessionContext(context);
+		for (const child of liveComponents) {
+			this.chatContainer.addChild(child);
+		}
+		// `renderSessionContext` clears `pendingTools` at start AND end so the
+		// reconstructed historical tool components don't leak into live tracking.
+		// Restore the in-flight entries afterwards so the next streamed tool-call
+		// delta is routed into the preserved component instead of stacking a
+		// duplicate ToolExecutionComponent below it.
+		for (const [id, component] of livePendingTools) {
+			this.pendingTools.set(id, component);
+		}
 		// During the pre-streaming window — after `startPendingSubmission` has
 		// optimistically rendered the user's message but before the user
 		// `message_start` event lands it in `session` entries — any rebuild
@@ -3583,6 +3636,9 @@ export class InteractiveMode implements InteractiveModeContext {
 		sessionContext: SessionContext,
 		options?: { updateFooter?: boolean; populateHistory?: boolean },
 	): void {
+		for (const message of sessionContext.messages) {
+			this.noteDisplayableThinkingContent(message);
+		}
 		this.#uiHelpers.renderSessionContext(sessionContext, options);
 	}
 
@@ -3844,6 +3900,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#selectorController.showSettingsSelector();
 	}
 
+	showAdvisorConfigure(): void {
+		this.#selectorController.showAdvisorConfigure();
+	}
+
 	showHistorySearch(): void {
 		this.#selectorController.showHistorySearch();
 	}

package/src/modes/skill-command.ts

@@ -0,0 +1,116 @@
+import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
+import { type CustomMessage, SKILL_PROMPT_MESSAGE_TYPE, type SkillPromptDetails } from "../session/messages";
+import type { InteractiveModeContext } from "./types";
+
+type SkillCommandHost = Pick<InteractiveModeContext, "skillCommands" | "session" | "showError">;
+
+type SkillPromptMessage = Pick<
+	CustomMessage<SkillPromptDetails>,
+	"customType" | "content" | "display" | "details" | "attribution"
+> & {
+	customType: typeof SKILL_PROMPT_MESSAGE_TYPE;
+	content: string | (TextContent | ImageContent)[];
+	display: true;
+	details: SkillPromptDetails;
+	attribution: "user";
+};
+
+type SkillPromptOptions = {
+	streamingBehavior: "steer" | "followUp";
+	queueChipText: string;
+};
+
+interface ParsedSkillCommand {
+	commandName: string;
+	args: string;
+}
+
+interface InvokeSkillCommandOptions {
+	propagateErrors?: boolean;
+	queueOnly?: boolean;
+	images?: ImageContent[];
+}
+
+/** Built custom-message payload and delivery options for a `/skill:` command. */
+export interface BuiltSkillCommandPrompt {
+	message: SkillPromptMessage;
+	options: SkillPromptOptions;
+}
+
+function parseSkillCommand(text: string): ParsedSkillCommand | undefined {
+	if (!text.startsWith("/skill:")) return undefined;
+	const spaceIndex = text.indexOf(" ");
+	const commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
+	const args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1).trim();
+	return { commandName, args };
+}
+
+/** Return true when `text` names a registered `/skill:<name>` command. */
+export function isKnownSkillCommand(ctx: SkillCommandHost, text: string): boolean {
+	const parsed = parseSkillCommand(text);
+	if (!parsed) return false;
+	return ctx.skillCommands.has(parsed.commandName);
+}
+
+/** Build the user-attributed custom message for a registered `/skill:<name>` command. */
+export async function buildSkillCommandPrompt(
+	ctx: SkillCommandHost,
+	text: string,
+	streamingBehavior: "steer" | "followUp",
+	images?: ImageContent[],
+): Promise<BuiltSkillCommandPrompt | undefined> {
+	const parsed = parseSkillCommand(text);
+	if (!parsed) return undefined;
+	const skillPath = ctx.skillCommands.get(parsed.commandName);
+	if (!skillPath) return undefined;
+
+	const content = await Bun.file(skillPath).text();
+	const body = content.replace(/^---\n[\s\S]*?\n---\n/, "").trim();
+	const metaLines = [`Skill: ${skillPath}`];
+	if (parsed.args) {
+		metaLines.push(`User: ${parsed.args}`);
+	}
+	const message = `${body}\n\n---\n\n${metaLines.join("\n")}`;
+	const textBlock: TextContent = { type: "text", text: message };
+	const promptContent = images && images.length > 0 ? [textBlock, ...images] : message;
+	const skillName = parsed.commandName.slice("skill:".length);
+	const details: SkillPromptDetails = {
+		name: skillName || parsed.commandName,
+		path: skillPath,
+		args: parsed.args || undefined,
+		lineCount: body ? body.split("\n").length : 0,
+	};
+
+	return {
+		message: {
+			customType: SKILL_PROMPT_MESSAGE_TYPE,
+			content: promptContent,
+			display: true,
+			details,
+			attribution: "user",
+		},
+		options: { streamingBehavior, queueChipText: text },
+	};
+}
+
+/** Invoke a registered `/skill:<name>` command as a user-attributed custom message. */
+export async function invokeSkillCommandFromText(
+	ctx: SkillCommandHost,
+	text: string,
+	streamingBehavior: "steer" | "followUp",
+	options?: InvokeSkillCommandOptions,
+): Promise<boolean> {
+	try {
+		const built = await buildSkillCommandPrompt(ctx, text, streamingBehavior, options?.images);
+		if (!built) return false;
+		const promptOptions = options?.queueOnly ? { ...built.options, queueOnly: true } : built.options;
+		await ctx.session.promptCustomMessage(built.message, promptOptions);
+		return true;
+	} catch (err) {
+		if (options?.propagateErrors) {
+			throw err;
+		}
+		ctx.showError(`Failed to load skill: ${err instanceof Error ? err.message : String(err)}`);
+		return true;
+	}
+}

package/src/modes/types.ts

@@ -161,10 +161,14 @@ export interface InteractiveModeContext {
 	hideThinkingBlock: boolean;
 	/**
 	 * Effective thinking-block visibility: true when hidden by user setting OR
-	 * thinking level is "off". Read this in render paths instead of
-	 * {@link hideThinkingBlock} so blocks are auto-hidden when thinking is off.
+	 * thinking level is "off" before the session has produced displayable
+	 * thinking content.
 	 */
 	readonly effectiveHideThinkingBlock: boolean;
+	/** Whether this visible session has produced thinking content the user can reveal. */
+	readonly hasDisplayableThinkingContent: boolean;
+	/** Record a message whose thinking content makes Ctrl+T meaningful even at thinking level "off"; returns true on first observation. */
+	noteDisplayableThinkingContent(message: AgentMessage): boolean;
 	proseOnlyThinking: boolean;
 	compactionQueuedMessages: CompactionQueuedMessage[];
 	pendingTools: Map<string, ToolExecutionHandle>;
@@ -342,6 +346,7 @@ export interface InteractiveModeContext {
 
 	// Selector handling
 	showSettingsSelector(): void;
+	showAdvisorConfigure(): void;
 	showHistorySearch(): void;
 	showExtensionsDashboard(): void;
 	showAgentsDashboard(): void;

package/src/modes/utils/ui-helpers.ts

@@ -45,6 +45,7 @@ import {
 	type SkillPromptDetails,
 } from "../../session/messages";
 import type { SessionContext } from "../../session/session-context";
+import { buildSkillCommandPrompt, invokeSkillCommandFromText, isKnownSkillCommand } from "../skill-command";
 import { createAssistantMessageComponent } from "./interactive-context-helpers";
 import {
 	assistantHasVisibleContent,
@@ -667,6 +668,15 @@ export class UiHelpers {
 	}
 
 	async #deliverQueuedMessage(message: CompactionQueuedMessage): Promise<void> {
+		if (
+			await invokeSkillCommandFromText(this.ctx, message.text, message.mode, {
+				propagateErrors: true,
+				queueOnly: true,
+				images: message.images,
+			})
+		) {
+			return;
+		}
 		if (this.ctx.isKnownSlashCommand(message.text)) {
 			await this.ctx.session.prompt(message.text);
 			return;
@@ -754,29 +764,37 @@ export class UiHelpers {
 				await this.#deliverQueuedMessage(message);
 			}
 
-			// Pass streamingBehavior so that if the session is still streaming when
-			// compaction-end fires (race window between isStreaming flipping false and
-			// the event landing here), prompt() routes the message into the steer/
-			// follow-up queue instead of throwing AgentBusyError. When the session is
-			// genuinely idle, streamingBehavior is ignored and a fresh prompt runs as
-			// before. This keeps the steer preview honest: if delivery has to be
-			// deferred, the message lands in the same queue every other consumer
-			// (Alt+Up dequeue, post-stream drain) already drains, instead of being
-			// stranded in compactionQueuedMessages with no drainer.
-			//
-			// firstPrompt is fire-and-forget — its rejection is funneled through
-			// `restoreQueue` rather than rethrown, so we use the primitive
-			// recordLocalSubmission and dispose manually in the catch.
-			const disposeFirstPrompt = this.ctx.recordLocalSubmission(firstPrompt.text, firstPrompt.images?.length ?? 0);
-			const promptPromise = this.ctx.session
-				.prompt(firstPrompt.text, {
-					streamingBehavior: firstPrompt.mode === "followUp" ? "followUp" : "steer",
-					images: firstPrompt.images,
-				})
-				.catch((error: unknown) => {
-					disposeFirstPrompt();
-					restoreQueue(error);
-				});
+			// First prompt is fire-and-forget — its rejection is funneled through
+			// `restoreQueue` rather than rethrown. Plain prompts use primitive
+			// recordLocalSubmission and dispose manually in the catch. Skill prompts
+			// are rebuilt as user-attributed custom messages so queued `/skill:` text
+			// is not sent as a literal prompt after compaction.
+			let promptPromise: Promise<unknown>;
+			if (isKnownSkillCommand(this.ctx, firstPrompt.text)) {
+				const built = await buildSkillCommandPrompt(
+					this.ctx,
+					firstPrompt.text,
+					firstPrompt.mode,
+					firstPrompt.images,
+				);
+				promptPromise = built
+					? this.ctx.session.promptCustomMessage(built.message, built.options).catch(restoreQueue)
+					: Promise.resolve();
+			} else {
+				const disposeFirstPrompt = this.ctx.recordLocalSubmission(
+					firstPrompt.text,
+					firstPrompt.images?.length ?? 0,
+				);
+				promptPromise = this.ctx.session
+					.prompt(firstPrompt.text, {
+						streamingBehavior: firstPrompt.mode === "followUp" ? "followUp" : "steer",
+						images: firstPrompt.images,
+					})
+					.catch((error: unknown) => {
+						disposeFirstPrompt();
+						restoreQueue(error);
+					});
+			}
 
 			for (const message of rest) {
 				await this.#deliverQueuedMessage(message);

package/src/prompts/agents/reviewer.md

@@ -1,7 +1,7 @@
 ---
 name: reviewer
 description: "Code review specialist for quality/security analysis"
-tools: read, grep, glob, bash, lsp, web_search, ast_grep, report_finding
+tools: read, grep, glob, bash, lsp, web_search, ast_grep
 spawns: explore
 model: pi/slow
 thinking-level: high
@@ -22,7 +22,7 @@ output:
   optionalProperties:
     findings:
       metadata:
-        description: Auto-populated from report_finding; don't set manually
+        description: "Populate via incremental yield sections under type: [\"findings\"]; don't repeat it in a final payload."
       elements:
         properties:
           title:
@@ -60,8 +60,8 @@ Identify bugs the author would want fixed before merge.
 <procedure>
 1. Run `git diff`, `jj diff --git`, or `gh pr diff <number>` to view patch
 2. Read modified files for full context
-3. Call `report_finding` per issue
-4. Call `yield` with verdict
+3. Record each issue with incremental `yield` using `type: ["findings"]`
+4. Record `overall_correctness`, `explanation`, and `confidence` with incremental `yield` sections, then stop so idle finalization assembles the result
 
 Bash is read-only: `git diff`, `git log`, `git show`, `jj diff --git`, `gh pr diff`. You NEVER make file edits or trigger builds.
 </procedure>
@@ -115,7 +115,7 @@ memcpy(buf, data.ptr, data.length);
 </example>
 
 <output>
-Each `report_finding` requires:
+Each finding uses incremental `yield` with `type: ["findings"]` and `result.data` containing:
 - `title`: Imperative, ≤80 chars
 - `body`: One paragraph
 - `priority`: 0-3
@@ -123,11 +123,12 @@ Each `report_finding` requires:
 - `file_path`: Path to affected file
 - `line_start`, `line_end`: Range ≤10 lines, must overlap diff
 
-Final `yield` call (payload under `result.data`):
-- `result.data.overall_correctness`: "correct" (no bugs/blockers) or "incorrect"
-- `result.data.explanation`: Plain text, 1-3 sentences summarizing verdict. Don't repeat findings (captured via `report_finding`).
-- `result.data.confidence`: 0.0-1.0
-- `result.data.findings`: Optional; MUST omit (auto-populated from `report_finding`)
+Verdict fields also use incremental `yield` sections:
+- `type: ["overall_correctness"]` with `"correct"` (no bugs/blockers) or `"incorrect"`
+- `type: ["explanation"]` with a plain-text 1-3 sentence verdict summary
+- `type: ["confidence"]` with a 0.0-1.0 confidence value
+
+Do not emit a separate submit tool call or duplicate `findings` in another payload. Once all sections are recorded, stop and let idle finalization assemble the result.
 
 You NEVER output JSON or code blocks.
 

package/src/prompts/review-custom-request.md

@@ -14,8 +14,7 @@ Create exactly **1 reviewer task**. Its assignment MUST include the custom instr
 Reviewer MUST:
 1. Follow the custom instructions below
 2. Read the referenced files or workspace context needed to evaluate them
-3. Call `report_finding` per issue
-4. Call `yield` with verdict when done
+3. Use incremental `yield` sections for findings and verdict fields; do NOT call a separate finding tool
 
 ### Custom Instructions
 

package/src/prompts/review-request.md

@@ -38,8 +38,7 @@ Reviewer MUST:
 1. Focus ONLY on assigned files
 2. {{#if skipDiff}}{{diffInstruction}}{{else}}MUST use diff hunks below (NEVER re-run git diff){{/if}}
 3. {{contextInstruction}}
-4. Call `report_finding` per issue
-5. Call `yield` with verdict when done
+4. Use incremental `yield` sections for findings and verdict fields; do NOT call a separate finding tool
 
 {{#if skipDiff}}
 ### Diff Previews

package/src/prompts/system/interrupted-thinking.md

@@ -0,0 +1,7 @@
+<system-notice type="interrupted-thinking">
+Your previous turn was interrupted while you were thinking.
+- You MUST treat the preserved reasoning as internal continuity context.
+- You MUST continue the user's task from the relevant unfinished point.
+------
+{{reasoning}}
+</system-notice>

package/src/prompts/system/recap-user.md

@@ -0,0 +1,9 @@
+<recap>
+The user stepped away and is coming back. Recap in under 40 words, 1-2 plain sentences, no markdown. Lead with the overall goal and current task, then the one next action. Skip root-cause narrative, fix internals, secondary to-dos, and em-dash tangents.
+{{#if goal}}
+Overall goal: {{goal}}
+{{/if}}
+{{#if task}}
+Active task: {{task}}
+{{/if}}
+</recap>

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

@@ -50,13 +50,16 @@ Use `irc` only for quick coordination, never long-form content. Address peers by
 COMPLETION
 ===================================
 
-No TODO tracking, no progress updates. Execute, call `yield`, done.
+No TODO tracking, no progress updates. Execute; report results with `yield`.
 
-While work remains, you MUST continue with another tool call — investigate, edit, run, verify. Save narrative for the final `yield` payload.
+While work remains, you MUST continue with another tool call — investigate, edit, run, verify. Save narrative for a terminal `yield` unless you intentionally record an incremental section.
 
-When finished, you MUST call `yield` exactly once. This is like writing to a ticket: provide what is required and close it.
+Yield protocol:
+- Omit `type` for the normal single terminal structured result in `result.data`.
+- Use non-empty `type: string[]` for incremental, non-terminal sections; calls accumulate by section.
+- Use `type: string` for a terminal result; if data is omitted, your last assistant turn becomes the raw final result.
 
-This is your only way to return a result. You NEVER put JSON in plain text, and you NEVER substitute a text summary for the structured `result.data` parameter.
+This is your only way to return a final result. For structured results, you NEVER put JSON in plain text or substitute a text summary for `result.data`.
 
 {{#if outputSchema}}
 Your result MUST match this TypeScript interface:
@@ -65,7 +68,7 @@ Your result MUST match this TypeScript interface:
 ```
 {{/if}}
 
-Giving up is a last resort. If truly blocked, you MUST call `yield` exactly once with `result.error` describing what you tried and the exact blocker.
+Giving up is a last resort. If truly blocked, you MUST terminal-yield `result.error` describing what you tried and the exact blocker.
 You NEVER give up due to uncertainty, missing information obtainable via tools or repo context, or needing a design decision you can derive yourself.
 
 You MUST keep going until this ticket is closed. This matters.

package/src/prompts/system/subagent-yield-reminder.md

@@ -1,12 +1,13 @@
 <system-reminder>
 Your last turn ended without a tool call, so the session went idle. This is reminder {{retryCount}} of {{maxRetries}}.
 
-Every turn MUST end with a tool call. Pick exactly one of:
-1. **Resume the work** — if the assignment is not finished, call the next tool you would have called (edit, write, bash, search, etc.). NEVER yield. NEVER treat this reminder as a forced stop.
-2. **Yield with success** — only if the assignment is genuinely complete: call `yield` with the structured payload in `result.data`.
-3. **Yield with error** — only if you hit a real, concrete blocker you can name (missing file, unavailable API, contradictory spec). Describe what you tried and the exact blocker. NEVER fabricate a "forced immediate-yield" or "system reminder required termination" reason — this reminder is not a blocker.
+Every turn MUST end with a tool call. Pick the first that applies:
+1. **Resume the work** — if the assignment is not finished and you are not recording an incremental section, call the next tool you would have called (edit, write, bash, search, etc.). NEVER treat this reminder as a forced stop.
+2. **Yield an incremental section** — only when useful for the assignment: call `yield` with non-empty `type: string[]`; matching sections accumulate and the task continues.
+3. **Yield with success** — only if the assignment is genuinely complete: call terminal `yield`. Omit `type` for the single final structured result in `result.data`; use `type: string` to finalize from the last assistant turn when data is omitted.
+4. **Yield with error** — only if you hit a real, concrete blocker you can name (missing file, unavailable API, contradictory spec). Describe what you tried and the exact blocker. NEVER fabricate a "forced immediate-yield" or "system reminder required termination" reason — this reminder is not a blocker.
 
-Default to option 1 unless the work is actually done or actually blocked.
+Default to option 1 unless the work is actually done, actually blocked, or ready for an incremental section.
 
 You NEVER end this turn with text only.
 </system-reminder>

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

@@ -58,7 +58,6 @@ Special URLs for internal resources; with most FS/bash tools they auto-resolve t
   {{/if}}
 - `agent://<id>`: agent output artifact; `/<path>` extracts a JSON field
 - `artifact://<id>`: artifact content
-- `history://<agentId>`: agent transcript (markdown); bare `history://` lists agents
 - `local://<name>.md`: plan artifacts or shared content for subagents
 {{#if hasObsidian}}
 - `vault://<vault>/<path>`: Obsidian vault (read/edit). `vault://` lists vaults; `vault://_/…` targets the active vault. File ops `?op=outline|backlinks|links|tags|properties|tasks|base|…`; vault ops `?op=search&q=…|daily|tasks|orphans|unresolved|bases|…`.

package/src/prompts/tools/irc.md

@@ -7,7 +7,7 @@ Send/receive short text messages between agents in this process.
 - Messaging an `idle`/`parked` peer wakes it — no separate revive call.
 - `op: "wait"` — block for a message (optionally only `from` one peer); consumes + returns it. Timeout = clean "no message", not an error.
 - `op: "inbox"` — drain pending messages without blocking.
-- Replies arrive only when the recipient sends one. For peer background, `read` `history://<id>`, don't interrogate.
+- Replies arrive only when the recipient sends one; don't interrogate a peer for status.
 </instruction>
 
 <when_to_use>
@@ -24,7 +24,7 @@ NEVER for: routine progress updates, things a tool call can verify, questions yo
 Applies to sending + replying.
 - **Plain prose only.** NEVER JSON status payloads like `{"type":"task_completed",…}` — write a normal sentence.
 - **NEVER quote the message you answer.** Lead with the answer; set `replyTo`.
-- **Learn about peers via IRC** — NEVER grep artifacts, read other sessions' JSONL, or shell-poke. DM them, or `read` `history://<id>`.
+- **Learn about peers via IRC** — NEVER grep artifacts, read other sessions' JSONL, or shell-poke. DM them.
 - **Send, then keep working.** `wait`/`await: true` only when you cannot proceed. NEVER "did you get my message?". A `failed` receipt = peer unreachable — move on; NEVER retry in a loop.
 - **Answer expected questions** via `irc send` to the sender (finish your current step first).
 - **Stay terse.** One question per send; share files via `local://`/`memory://`/`artifact://` URLs, never pasted blobs.

package/src/prompts/tools/read.md

@@ -7,7 +7,7 @@ Read files, directories, archives, SQLite, images, documents, internal resources
 
 ## Parameters
 
-- `path` — required. Local path, internal URI (`skill://`, `agent://`, `artifact://`, `history://`, `memory://`, `rule://`, `local://`, `vault://`, `mcp://`, `omp://`, `issue://`, `pr://`, `ssh://`), or URL. Append `:<sel>` for ranges/modes (e.g. `src/foo.ts:50-200`, `src/foo.ts:raw`, `db.sqlite:users:42`).
+- `path` — required. Local path, internal URI (`skill://`, `agent://`, `artifact://`, `memory://`, `rule://`, `local://`, `vault://`, `mcp://`, `omp://`, `issue://`, `pr://`, `ssh://`), or URL. Append `:<sel>` for ranges/modes (e.g. `src/foo.ts:50-200`, `src/foo.ts:raw`, `db.sqlite:users:42`).
 
 ## Selectors
 
@@ -67,7 +67,7 @@ For `.sqlite`, `.sqlite3`, `.db`, `.db3`:
 
 # Internal URIs
 
-All URI schemes take the same line selectors. `artifact://<id>` recovers full output a bash/eval/tool result spilled or truncated. `history://<agentId>` = agent transcript; bare `history://` lists agents.
+All URI schemes take the same line selectors. `artifact://<id>` recovers full output a bash/eval/tool result spilled or truncated.
 
 `ssh://host/<absolute-path>` reads a remote text file (UTF-8, ≤1 MiB) or lists a directory one level deep, on a pre-configured SSH host or `~/.ssh/config` alias; `ssh://host/` lists the remote root and bare `ssh://` lists the configured hosts. Files are also writable via `write` and searchable via `search`; a directory only lists (`search` refuses a directory, `write` refuses to overwrite one). A literal `:`, `?`, or `#` in the remote path must be percent-encoded (`%3A`/`%3F`/`%23`) — a trailing `:sel` is read as a line selector, and `?`/`#` start a URL query/fragment. Requires a POSIX login shell (`sh`/`bash`/`zsh`); a Windows host or a non-POSIX shell (fish, csh/tcsh) is rejected — use the `ssh` tool there.