@oh-my-pi/pi-coding-agent 14.4.1 → 14.4.4

package/src/session/agent-session.ts

@@ -27,6 +27,7 @@ import {
 } from "@oh-my-pi/pi-agent-core";
 import type {
 	AssistantMessage,
+	Context,
 	Effort,
 	ImageContent,
 	Message,
@@ -48,6 +49,7 @@ import {
 	isUsageLimitError,
 	modelsAreEqual,
 	parseRateLimitReason,
+	streamSimple,
 } from "@oh-my-pi/pi-ai";
 import { killTree, MacOSPowerAssertion } from "@oh-my-pi/pi-natives";
 import {
@@ -121,6 +123,7 @@ import type { PlanModeState } from "../plan-mode/state";
 import autoHandoffThresholdFocusPrompt from "../prompts/system/auto-handoff-threshold-focus.md" with { type: "text" };
 import eagerTodoPrompt from "../prompts/system/eager-todo.md" with { type: "text" };
 import handoffDocumentPrompt from "../prompts/system/handoff-document.md" with { type: "text" };
+import ircIncomingTemplate from "../prompts/system/irc-incoming.md" with { type: "text" };
 import planModeActivePrompt from "../prompts/system/plan-mode-active.md" with { type: "text" };
 import planModeReferencePrompt from "../prompts/system/plan-mode-reference.md" with { type: "text" };
 import planModeToolDecisionReminderPrompt from "../prompts/system/plan-mode-tool-decision-reminder.md" with {
@@ -469,6 +472,11 @@ export class AgentSession {
 	#pendingPythonMessages: PythonExecutionMessage[] = [];
 	#activePythonExecutions = new Set<Promise<unknown>>();
 	#pythonExecutionDisposing = false;
+
+	// Background-channel IRC exchanges queued while the recipient was streaming.
+	// Drained into history (via emitExternalEvent) once the recipient becomes idle.
+	#pendingBackgroundExchanges: CustomMessage[][] = [];
+	#scheduledBackgroundExchangeFlush = false;
 	// Extension system
 	#extensionRunner: ExtensionRunner | undefined = undefined;
 	#turnIndex = 0;
@@ -2653,6 +2661,7 @@ export class AgentSession {
 			// Flush any pending bash messages before the new prompt
 			this.#flushPendingBashMessages();
 			this.#flushPendingPythonMessages();
+			this.#flushPendingBackgroundExchanges();
 
 			// Reset todo reminder count on new user prompt
 			this.#todoReminderCount = 0;
@@ -3237,11 +3246,11 @@ export class AgentSession {
 		return phases.map(phase => ({
 			id: phase.id,
 			name: phase.name,
-			tasks: phase.tasks.map(task => ({
-				id: task.id,
-				content: task.content,
-				status: task.status,
-			})),
+			tasks: phase.tasks.map(task => {
+				const out: TodoItem = { id: task.id, content: task.content, status: task.status };
+				if (task.notes && task.notes.length > 0) out.notes = [...task.notes];
+				return out;
+			}),
 		}));
 	}
 
@@ -3364,7 +3373,15 @@ export class AgentSession {
 		this.#asyncJobManager?.cancelAll();
 		this.#closeAllProviderSessions("new session");
 		this.agent.reset();
-		await this.sessionManager.flush();
+		if (options?.drop && previousSessionFile) {
+			try {
+				await this.sessionManager.dropSession(previousSessionFile);
+			} catch (err) {
+				logger.error("Failed to delete session during /drop", { err });
+			}
+		} else {
+			await this.sessionManager.flush();
+		}
 		await this.sessionManager.newSession(options);
 		this.setTodoPhases([]);
 		this.agent.sessionId = this.sessionManager.getSessionId();
@@ -5924,6 +5941,209 @@ export class AgentSession {
 		this.#pendingPythonMessages = [];
 	}
 
+	// =========================================================================
+	// Background-Channel IRC Exchanges
+	// =========================================================================
+
+	/**
+	 * Generate an ephemeral reply to a background message (e.g. an IRC ping from
+	 * another agent) using this session's current model + system prompt + history.
+	 *
+	 * The reply is computed via a side-channel `streamSimple` call (analogous to
+	 * `/btw`) so it never blocks on the recipient's in-flight tool calls.  After
+	 * the reply is generated, both the incoming question and the auto-reply are
+	 * queued for injection into the recipient's persisted history so the model
+	 * sees the exchange on its next turn.  Injection happens immediately when the
+	 * session is idle, otherwise it is deferred until streaming ends.
+	 */
+	async respondAsBackground(args: {
+		from: string;
+		message: string;
+		awaitReply?: boolean;
+		signal?: AbortSignal;
+	}): Promise<{ replyText: string | null }> {
+		const awaitReply = args.awaitReply !== false;
+		const incomingTimestamp = Date.now();
+		const incomingRecord: CustomMessage = {
+			role: "custom",
+			customType: "irc:incoming",
+			content: `[IRC \`${args.from}\` \u2192 you]\n\n${args.message}`,
+			display: true,
+			details: { from: args.from, message: args.message },
+			attribution: "agent",
+			timestamp: incomingTimestamp,
+		};
+
+		if (!awaitReply) {
+			this.#queueBackgroundExchangeInjection([incomingRecord]);
+			return { replyText: null };
+		}
+
+		const incomingPrompt = prompt.render(ircIncomingTemplate, {
+			from: args.from,
+			message: args.message,
+		});
+		const { replyText } = await this.runEphemeralTurn({
+			promptText: incomingPrompt,
+			signal: args.signal,
+		});
+
+		const replyRecord: CustomMessage = {
+			role: "custom",
+			customType: "irc:autoreply",
+			content: `[IRC you \u2192 \`${args.from}\` (auto)]\n\n${replyText}`,
+			display: true,
+			details: { to: args.from, reply: replyText },
+			attribution: "agent",
+			timestamp: Date.now(),
+		};
+		this.#queueBackgroundExchangeInjection([incomingRecord, replyRecord]);
+
+		return { replyText };
+	}
+
+	/**
+	 * Run a single ephemeral side-channel turn against this session's current
+	 * model + system prompt + history.  No tools are used; the side request
+	 * does not block on, or interfere with, any in-flight main turn.  The
+	 * session's history and persisted state are NOT modified by this call.
+	 *
+	 * Used by `respondAsBackground` (IRC) and `BtwController` (`/btw`) to share
+	 * the snapshot + stream pipeline.  The snapshot includes any in-flight
+	 * streaming assistant text so the model sees the half-finished response
+	 * rather than missing context.
+	 */
+	async runEphemeralTurn(args: {
+		promptText: string;
+		onTextDelta?: (delta: string) => void;
+		signal?: AbortSignal;
+	}): Promise<{ replyText: string; assistantMessage: AssistantMessage }> {
+		const model = this.model;
+		if (!model) {
+			throw new Error("No active model on session");
+		}
+		const apiKey = await this.#modelRegistry.getApiKey(model, this.sessionId);
+		if (!apiKey) {
+			throw new Error(`No API key for ${model.provider}/${model.id}`);
+		}
+
+		const snapshot = this.#buildEphemeralSnapshot(args.promptText);
+		const llmMessages = await this.convertMessagesToLlm(snapshot, args.signal);
+		const context: Context = {
+			systemPrompt: this.systemPrompt,
+			messages: llmMessages,
+		};
+		const options = this.prepareSimpleStreamOptions({
+			apiKey,
+			sessionId: this.sessionId,
+			reasoning: toReasoningEffort(this.thinkingLevel),
+			serviceTier: this.serviceTier,
+			signal: args.signal,
+			toolChoice: "none",
+		});
+
+		let replyText = "";
+		let assistantMessage: AssistantMessage | undefined;
+		const stream = streamSimple(model, context, options);
+		for await (const event of stream) {
+			if (event.type === "text_delta") {
+				replyText += event.delta;
+				if (args.onTextDelta) args.onTextDelta(event.delta);
+				continue;
+			}
+			if (event.type === "done") {
+				assistantMessage = event.message;
+				break;
+			}
+			if (event.type === "error") {
+				throw new Error(event.error.errorMessage || "Ephemeral turn failed");
+			}
+		}
+
+		if (!assistantMessage) {
+			throw new Error("Ephemeral turn ended without a final message");
+		}
+		return { replyText: replyText.trim(), assistantMessage };
+	}
+
+	/**
+	 * Build a message snapshot for an ephemeral side-channel turn.  Includes
+	 * the in-flight streaming assistant message (if any) so the model sees
+	 * the partial response in context, then appends the prompt as a virtual
+	 * user message.
+	 */
+	#buildEphemeralSnapshot(promptText: string): AgentMessage[] {
+		const messages = [...this.messages];
+		const streaming = this.agent.state.streamMessage;
+		if (streaming && streaming.role === "assistant") {
+			const streamingText = streaming.content
+				.filter((c): c is TextContent => c.type === "text")
+				.map(c => c.text)
+				.join("");
+			if (streamingText) {
+				const normalized: AssistantMessage = {
+					...streaming,
+					content: [{ type: "text", text: streamingText }],
+				};
+				const lastMessage = messages.at(-1);
+				if (lastMessage?.role === "assistant") {
+					messages[messages.length - 1] = normalized;
+				} else {
+					messages.push(normalized);
+				}
+			}
+		}
+		messages.push({
+			role: "user",
+			content: [{ type: "text", text: promptText }],
+			attribution: "agent",
+			timestamp: Date.now(),
+		});
+		return messages;
+	}
+
+	#queueBackgroundExchangeInjection(messages: CustomMessage[]): void {
+		this.#pendingBackgroundExchanges.push(messages);
+		if (!this.isStreaming) {
+			this.#flushPendingBackgroundExchanges();
+			return;
+		}
+		this.#scheduleBackgroundExchangeFlush();
+	}
+
+	#scheduleBackgroundExchangeFlush(): void {
+		if (this.#scheduledBackgroundExchangeFlush) return;
+		this.#scheduledBackgroundExchangeFlush = true;
+		const attempt = (): void => {
+			if (this.#pendingBackgroundExchanges.length === 0) {
+				this.#scheduledBackgroundExchangeFlush = false;
+				return;
+			}
+			if (this.isStreaming) {
+				setTimeout(attempt, 50);
+				return;
+			}
+			this.#scheduledBackgroundExchangeFlush = false;
+			this.#flushPendingBackgroundExchanges();
+		};
+		setTimeout(attempt, 0);
+	}
+
+	#flushPendingBackgroundExchanges(): void {
+		if (this.#pendingBackgroundExchanges.length === 0) return;
+		const batches = this.#pendingBackgroundExchanges;
+		this.#pendingBackgroundExchanges = [];
+		for (const batch of batches) {
+			for (const msg of batch) {
+				// emitExternalEvent on message_end appends to agent state and dispatches
+				// to all session listeners, which in turn handle TUI rendering and
+				// sessionManager persistence via #handleAgentEvent.
+				this.agent.emitExternalEvent({ type: "message_start", message: msg });
+				this.agent.emitExternalEvent({ type: "message_end", message: msg });
+			}
+		}
+	}
+
 	// =========================================================================
 	// Session Management
 	// =========================================================================

package/src/session/session-manager.ts

@@ -66,6 +66,8 @@ export interface SessionHeader {
 
 export interface NewSessionOptions {
 	parentSession?: string;
+	/** Skip flushing the current session and delete it instead of saving. */
+	drop?: boolean;
 }
 
 export interface SessionEntryBase {
@@ -1707,6 +1709,17 @@ export class SessionManager {
 		return this.#newSessionSync(options);
 	}
 
+	/** Delete a session file and its artifacts. Drains the persist writer first to avoid EPERM on Windows. ENOENT is treated as success. */
+	async dropSession(sessionPath: string): Promise<void> {
+		await this.#closePersistWriter();
+		try {
+			await this.storage.deleteSessionWithArtifacts(sessionPath);
+		} catch (err) {
+			if (isEnoent(err)) return;
+			throw err;
+		}
+	}
+
 	/**
 	 * Fork the current session, creating a new session file with the same entries.
 	 * Returns both the old and new session file paths for artifact copying.

package/src/session/session-storage.ts

@@ -32,6 +32,7 @@ export interface SessionStorage {
 	writeText(path: string, content: string): Promise<void>;
 	rename(path: string, nextPath: string): Promise<void>;
 	unlink(path: string): Promise<void>;
+	deleteSessionWithArtifacts(sessionPath: string): Promise<void>;
 	openWriter(path: string, options?: { flags?: "a" | "w"; onError?: (err: Error) => void }): SessionStorageWriter;
 }
 
@@ -360,6 +361,9 @@ export class MemorySessionStorage implements SessionStorage {
 		this.#files.delete(path);
 		return Promise.resolve();
 	}
+	deleteSessionWithArtifacts(_sessionPath: string): Promise<void> {
+		return Promise.resolve();
+	}
 
 	openWriter(path: string, options?: { flags?: "a" | "w"; onError?: (err: Error) => void }): SessionStorageWriter {
 		return new MemorySessionStorageWriter(this, path, options);

package/src/session/streaming-output.ts

@@ -759,7 +759,7 @@ export function formatHeadTruncationNotice(
 	const totalFileLines = options.totalFileLines ?? truncation.totalLines;
 	const endLineDisplay = startLineDisplay + (truncation.outputLines ?? truncation.totalLines) - 1;
 	const nextOffset = endLineDisplay + 1;
-	const notice = `[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use sel=L${nextOffset} to continue]`;
+	const notice = `[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use sel=${nextOffset} to continue]`;
 	return `\n\n${notice}`;
 }
 

package/src/slash-commands/builtin-registry.ts

@@ -259,6 +259,30 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "todo",
+		description: "View or modify the agent's todo list",
+		subcommands: [
+			{ name: "edit", description: "Open todos in $EDITOR (Markdown round-trip)" },
+			{ name: "copy", description: "Copy todos as Markdown to clipboard" },
+			{ name: "export", description: "Write todos as Markdown to a file (default: TODO.md)", usage: "[<path>]" },
+			{ name: "import", description: "Replace todos from a Markdown file (default: TODO.md)", usage: "[<path>]" },
+			{
+				name: "append",
+				description: "Append a task; phase fuzzy-matched or auto-created",
+				usage: "[<phase>] <task...>",
+			},
+			{ name: "start", description: "Mark task in_progress (fuzzy-matched)", usage: "<task>" },
+			{ name: "done", description: "Mark task/phase/all completed (fuzzy-matched)", usage: "[<task|phase>]" },
+			{ name: "drop", description: "Mark task/phase/all abandoned (fuzzy-matched)", usage: "[<task|phase>]" },
+			{ name: "rm", description: "Remove task/phase/all (fuzzy-matched)", usage: "[<task|phase>]" },
+		],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			await runtime.ctx.handleTodoCommand(command.args);
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "session",
 		description: "Session management commands",
@@ -488,6 +512,14 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			await runtime.ctx.handleClearCommand();
 		},
 	},
+	{
+		name: "drop",
+		description: "Delete the current session and start a new one",
+		handle: async (_command, runtime) => {
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleDropCommand();
+		},
+	},
 	{
 		name: "compact",
 		description: "Manually compact the session context",

package/src/task/executor.ts

@@ -20,6 +20,7 @@ import { callTool } from "../mcp/client";
 import type { MCPManager } from "../mcp/manager";
 import subagentSystemPromptTemplate from "../prompts/system/subagent-system-prompt.md" with { type: "text" };
 import submitReminderTemplate from "../prompts/system/subagent-yield-reminder.md" with { type: "text" };
+import { AgentRegistry } from "../registry/agent-registry";
 import { createAgentSession, discoverAuthStorage } from "../sdk";
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 import type { AuthStorage } from "../session/auth-storage";
@@ -73,6 +74,14 @@ function normalizeModelPatterns(value: string | string[] | undefined): string[]
 		.filter(Boolean);
 }
 
+function renderIrcPeerRoster(selfId: string): string {
+	const peers = AgentRegistry.global()
+		.list()
+		.filter(ref => ref.id !== selfId && (ref.status === "running" || ref.status === "idle"));
+	if (peers.length === 0) return "- (no other live agents)";
+	return peers.map(peer => `- \`${peer.id}\` — ${peer.displayName} (${peer.kind}, ${peer.status})`).join("\n");
+}
+
 function withAbortTimeout<T>(promise: Promise<T>, timeoutMs: number, signal?: AbortSignal): Promise<T> {
 	if (signal?.aborted) {
 		return Promise.reject(new ToolAbortError());
@@ -543,6 +552,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				: agent.spawns.join(",");
 
 	const lspEnabled = enableLsp ?? true;
+	const ircEnabled = subagentSettings.get("irc.enabled") === true;
 	const skipPythonPreflight = Array.isArray(toolNames) && !toolNames.includes("python");
 
 	const outputChunks: string[] = [];
@@ -962,12 +972,16 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						worktree: worktree ?? "",
 						outputSchema: normalizedOutputSchema,
 						contextFile: options.contextFile,
+						ircPeers: ircEnabled ? renderIrcPeerRoster(id) : "",
+						ircSelfId: ircEnabled ? id : "",
 					}),
 				sessionManager,
 				hasUI: false,
 				spawns: spawnsEnv,
 				taskDepth: childDepth,
 				parentTaskPrefix: id,
+				agentId: id,
+				agentDisplayName: agent.name,
 				enableLsp: lspEnabled,
 				skipPythonPreflight,
 				enableMCP,

package/src/tools/bash.ts

@@ -346,7 +346,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		}
 		lines.push(`Background job ${jobId} started: ${label}`);
 		lines.push("Result will be delivered automatically when complete.");
-		lines.push(`Use \`poll\`, \`read jobs://${jobId}\`, or \`cancel_job\` if needed.`);
+		lines.push(`Use \`job\` (with \`poll\` or \`cancel\`) or \`read jobs://${jobId}\` if needed.`);
 		return {
 			content: [{ type: "text", text: lines.join("\n") }],
 			details,

package/src/tools/fetch.ts

@@ -137,7 +137,9 @@ export function isReadableUrlPath(value: string): boolean {
 	return /^https?:\/\//i.test(value) || /^www\./i.test(value);
 }
 
-const URL_LINE_RANGE_RE = /^L(\d+)(?:-L?(\d+))?$/i;
+const URL_LINE_RANGE_RE = /^L?(\d+)(?:([-+])L?(\d+))?$/i;
+// Embedded URL selectors (after a `:` in the path) keep the explicit `L` prefix to avoid colliding with ports such as `https://example.com:50`.
+const URL_EMBEDDED_LINE_RANGE_RE = /^L\d+(?:[-+]L?\d+)?$/i;
 
 export interface ParsedReadUrlTarget {
 	path: string;
@@ -159,11 +161,21 @@ export function parseReadUrlTarget(readPath: string, sel?: string): ParsedReadUr
 	if (lineMatch) {
 		const startLine = Number.parseInt(lineMatch[1]!, 10);
 		if (startLine < 1) {
-			throw new ToolError("L0 is invalid; lines are 1-indexed. Use sel=L1.");
+			throw new ToolError("sel=0 is invalid; lines are 1-indexed. Use sel=1.");
 		}
-		const endLine = lineMatch[2] ? Number.parseInt(lineMatch[2], 10) : undefined;
-		if (endLine !== undefined && endLine < startLine) {
-			throw new ToolError(`Invalid range L${startLine}-L${endLine}: end must be >= start.`);
+		const sep = lineMatch[2];
+		const rhs = lineMatch[3] ? Number.parseInt(lineMatch[3], 10) : undefined;
+		let endLine: number | undefined;
+		if (sep === "+") {
+			if (rhs === undefined || rhs < 1) {
+				throw new ToolError(`Invalid range ${startLine}+${rhs ?? 0}: count must be >= 1.`);
+			}
+			endLine = startLine + rhs - 1;
+		} else if (sep === "-") {
+			if (rhs === undefined || rhs < startLine) {
+				throw new ToolError(`Invalid range ${startLine}-${rhs ?? 0}: end must be >= start.`);
+			}
+			endLine = rhs;
 		}
 		return {
 			path: urlPath,
@@ -183,7 +195,7 @@ function tryExtractEmbeddedUrlSelector(readPath: string): { path: string; sel?:
 	}
 
 	const candidateSelector = readPath.slice(lastColonIndex + 1);
-	const isEmbeddedSelector = candidateSelector === "raw" || URL_LINE_RANGE_RE.test(candidateSelector);
+	const isEmbeddedSelector = candidateSelector === "raw" || URL_EMBEDDED_LINE_RANGE_RE.test(candidateSelector);
 	if (!isEmbeddedSelector) {
 		return null;
 	}

package/src/tools/fs-cache-invalidation.ts

@@ -1,12 +1,10 @@
 import { invalidateFsScanCache } from "@oh-my-pi/pi-natives";
-import { invalidateChunkCache } from "../edit/modes/chunk";
 
 /**
  * Invalidate shared filesystem scan caches after a content write/update.
  */
 export function invalidateFsScanAfterWrite(path: string): void {
 	invalidateFsScanCache(path);
-	invalidateChunkCache(path);
 }
 
 /**
@@ -14,7 +12,6 @@ export function invalidateFsScanAfterWrite(path: string): void {
  */
 export function invalidateFsScanAfterDelete(path: string): void {
 	invalidateFsScanCache(path);
-	invalidateChunkCache(path);
 }
 
 /**
@@ -25,9 +22,7 @@ export function invalidateFsScanAfterDelete(path: string): void {
  */
 export function invalidateFsScanAfterRename(oldPath: string, newPath: string): void {
 	invalidateFsScanCache(oldPath);
-	invalidateChunkCache(oldPath);
 	if (newPath !== oldPath) {
 		invalidateFsScanCache(newPath);
-		invalidateChunkCache(newPath);
 	}
 }