@oh-my-pi/pi-coding-agent 15.10.11 → 15.11.0

package/dist/types/tools/irc.d.ts

@@ -1,58 +1,62 @@
 /**
- * IRC tool — agent-to-agent messaging.
+ * IRC tool — agent-to-agent messaging over the process-global IrcBus.
  *
- * Lets any live agent send a short prose message to any other live agent in
- * this process and (optionally) get a prose reply.
- *
- * Routing happens via the global AgentRegistry. Replies are produced by an
- * ephemeral side-channel call (`AgentSession.respondAsBackground`) that
- * mirrors `/btw`: the recipient's current model, system prompt, and message
- * history are used to compute a reply without persisting it through the
- * normal stream path. After the reply is generated, both the incoming
- * message and the auto-reply are queued for injection into the recipient's
- * persisted history (deferred until the recipient is idle), so the model
- * sees the exchange on its next turn.
- *
- * This avoids the deadlock that arises when the recipient is blocked on a
- * long-running tool call: the side-channel call does not depend on the
- * recipient's main agent loop being free.
+ * `send` is fire-and-forget: the bus routes the message to the recipient
+ * (waking idle agents with a real turn, reviving parked ones via the
+ * lifecycle manager, injecting a non-interrupting aside into busy ones) and
+ * returns delivery receipts immediately. Replies are real turns by the
+ * recipient, observed with `wait` (or the `await: true` send sugar). `inbox`
+ * drains pending messages; `list` shows every addressable peer.
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { type Component } from "@oh-my-pi/pi-tui";
 import * as z from "zod/v4";
+import type { Settings } from "../config/settings";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { type IrcDeliveryReceipt, type IrcMessage } from "../irc/bus";
+import type { Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
+/**
+ * IRC availability: there must be someone to chat with. True for every
+ * subagent (it always has a parent, and possibly siblings) and for any
+ * session that can still spawn subagents through the task tool. Only a
+ * top-level session with task spawning unavailable has no peers — no irc.
+ */
+export declare function isIrcEnabled(settings: Settings, taskDepth: number): boolean;
 declare const ircSchema: z.ZodObject<{
     op: z.ZodEnum<{
+        inbox: "inbox";
         list: "list";
         send: "send";
+        wait: "wait";
     }>;
     to: z.ZodOptional<z.ZodString>;
     message: z.ZodOptional<z.ZodString>;
-    awaitReply: z.ZodOptional<z.ZodBoolean>;
+    replyTo: z.ZodOptional<z.ZodString>;
+    await: z.ZodOptional<z.ZodBoolean>;
+    from: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    peek: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type IrcParams = z.infer<typeof ircSchema>;
-interface IrcReply {
-    from: string;
-    text: string;
+interface IrcPeerInfo {
+    id: string;
+    displayName: string;
+    kind: string;
+    status: string;
+    parentId?: string;
+    unread: number;
+    lastActivity: number;
 }
 export interface IrcDetails {
-    op: "send" | "list";
+    op: "send" | "wait" | "inbox" | "list";
     from?: string;
     to?: string;
-    delivered?: string[];
-    replies?: IrcReply[];
-    failed?: Array<{
-        id: string;
-        error: string;
-    }>;
-    notFound?: string[];
-    peers?: Array<{
-        id: string;
-        displayName: string;
-        kind: string;
-        status: string;
-        parentId?: string;
-    }>;
-    channels?: string[];
+    receipts?: IrcDeliveryReceipt[];
+    /** Message consumed by `wait` / `send await:true`; null when the wait timed out. */
+    waited?: IrcMessage | null;
+    inbox?: IrcMessage[];
+    peers?: IrcPeerInfo[];
 }
 export declare class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
     #private;
@@ -60,16 +64,22 @@ export declare class IrcTool implements AgentTool<typeof ircSchema, IrcDetails>
     readonly name = "irc";
     readonly approval: "read";
     readonly label = "IRC";
-    readonly summary = "Send and receive messages between agents over IRC-like channels";
+    readonly summary = "Send and receive messages between agents";
     readonly description: string;
     readonly parameters: z.ZodObject<{
         op: z.ZodEnum<{
+            inbox: "inbox";
             list: "list";
             send: "send";
+            wait: "wait";
         }>;
         to: z.ZodOptional<z.ZodString>;
         message: z.ZodOptional<z.ZodString>;
-        awaitReply: z.ZodOptional<z.ZodBoolean>;
+        replyTo: z.ZodOptional<z.ZodString>;
+        await: z.ZodOptional<z.ZodBoolean>;
+        from: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        peek: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;
     readonly strict = true;
     readonly loadMode = "discoverable";
@@ -77,4 +87,32 @@ export declare class IrcTool implements AgentTool<typeof ircSchema, IrcDetails>
     static createIf(session: ToolSession): IrcTool | null;
     execute(_toolCallId: string, params: IrcParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<IrcDetails>, _context?: AgentToolContext): Promise<AgentToolResult<IrcDetails>>;
 }
+type IrcRenderArgs = Partial<IrcParams>;
+/**
+ * Display-only transcript card for live IRC traffic: `irc:incoming` DMs
+ * delivered to this session and `irc:relay` observations of agent↔agent
+ * traffic. Shares the tool renderer's glyph + quote-border conventions so
+ * cards and `irc` tool output look identical in the transcript.
+ */
+export declare function createIrcMessageCard(card: {
+    kind: "incoming" | "relay";
+    from?: string;
+    to?: string;
+    body?: string;
+    replyTo?: string;
+    timestamp?: number;
+}, getExpanded: () => boolean, uiTheme: Theme): Component;
+export declare const ircToolRenderer: {
+    inline: boolean;
+    mergeCallAndResult: boolean;
+    renderCall(args: IrcRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: IrcDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: IrcRenderArgs): Component;
+};
 export {};

package/dist/types/tools/job.d.ts

@@ -27,6 +27,13 @@ export interface JobToolDetails {
         status: CancelStatus;
     }[];
 }
+/**
+ * A poll snapshot where every watched job is still running and nothing was
+ * cancelled — pure "still waiting" noise once a newer poll exists. The TUI
+ * keeps such a block un-finalized (displaceable) so a follow-up `job` call
+ * replaces it instead of stacking another waiting frame in the transcript.
+ */
+export declare function isWaitingPollDetails(details: unknown): boolean;
 export declare class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
     #private;
     private readonly session;
@@ -43,7 +50,6 @@ export declare class JobTool implements AgentTool<typeof jobSchema, JobToolDetai
     readonly strict = true;
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);
-    static createIf(session: ToolSession): JobTool | null;
     execute(_toolCallId: string, params: JobParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<JobToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<JobToolDetails>>;
 }
 interface JobRenderArgs {

package/dist/types/utils/git.d.ts

@@ -10,6 +10,7 @@ export interface GitRepository {
     gitEntryPath: string;
     headPath: string;
     repoRoot: string;
+    isReftable?: boolean;
 }
 export interface GitStatusSummary {
     staged: number;
@@ -327,7 +328,7 @@ export declare const ls: {
 };
 export declare const head: {
     /** Full HEAD state (branch, commit, repo info). */
-    resolve(cwd: string): Promise<GitHeadState | null>;
+    resolve(cwd: string, signal?: AbortSignal): Promise<GitHeadState | null>;
     /** Full HEAD state (synchronous). */
     resolveSync(cwd: string): GitHeadState | null;
     /** Current HEAD commit SHA. */
@@ -338,12 +339,24 @@ export declare const head: {
 export declare const repo: {
     /** Resolve the repository root (may be a worktree root). */
     root(cwd: string, signal?: AbortSignal): Promise<string | null>;
-    /** Resolve the primary repository root (not a worktree — the main checkout). */
+    /** Resolve the primary checkout root, or the shared common dir for bare-repo worktrees. */
     primaryRoot(cwd: string, signal?: AbortSignal): Promise<string | null>;
+    /**
+     * Sync sibling of {@link primaryRoot}. Resolves only via on-disk `.git`/
+     * `commondir` walking — no subprocess fallback — so it stays usable from
+     * paths where async I/O is impractical (e.g. `computeBankScope`). Returns
+     * `null` when `cwd` is outside a repository. Bare-repo worktrees resolve to
+     * the shared common dir (`foo.git`) because they have no primary checkout.
+     */
+    primaryRootSync(cwd: string): string | null;
     /** Full GitRepository metadata (sync). */
     resolveSync(cwd: string): GitRepository | null;
     /** Full GitRepository metadata. */
     resolve(cwd: string): Promise<GitRepository | null>;
+    /** Check if the repository uses the reftable reference storage format (sync). */
+    isReftableSync(repository: GitRepository): boolean;
+    /** Check if the repository uses the reftable reference storage format. */
+    isReftable(repository: GitRepository): Promise<boolean>;
 };
 export interface GhCommandResult {
     exitCode: number;

package/dist/types/utils/title-generator.d.ts

@@ -15,9 +15,10 @@ export declare function raceFirstNonNull<T>(primary: Promise<T | null>, startFal
  *   to produce request metadata (e.g. user_id for session attribution). Using a
  *   resolver instead of a pre-evaluated value ensures the metadata's account_uuid
  *   reflects the credential actually selected for this request.
+ * @param customSystemPrompt Optional title-specific system prompt override
  */
-export declare function generateSessionTitle(firstMessage: string, registry: ModelRegistry, settings: Settings, sessionId?: string, currentModel?: Model<Api>, metadataResolver?: (provider: string) => Record<string, unknown> | undefined): Promise<string | null>;
-export declare function generateTitleOnline(firstMessage: string, registry: ModelRegistry, settings: Settings, sessionId?: string, currentModel?: Model<Api>, metadataResolver?: (provider: string) => Record<string, unknown> | undefined, signal?: AbortSignal): Promise<string | null>;
+export declare function generateSessionTitle(firstMessage: string, registry: ModelRegistry, settings: Settings, sessionId?: string, currentModel?: Model<Api>, metadataResolver?: (provider: string) => Record<string, unknown> | undefined, customSystemPrompt?: string): Promise<string | null>;
+export declare function generateTitleOnline(firstMessage: string, registry: ModelRegistry, settings: Settings, sessionId?: string, currentModel?: Model<Api>, metadataResolver?: (provider: string) => Record<string, unknown> | undefined, signal?: AbortSignal, customSystemPrompt?: string): Promise<string | null>;
 export declare function formatSessionTerminalTitle(sessionName: string | undefined, cwd?: string): string;
 /**
  * Set the terminal title using OSC 0 (sets both tab and window title). Unsupported terminals ignore it.

package/examples/extensions/with-deps/package.json

@@ -1,6 +1,7 @@
 {
 	"name": "pi-extension-with-deps",
 	"version": "1.0.0",
+	"homepage": "https://omp.sh",
 	"type": "module",
 	"omp": {
 		"extensions": [

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.10.11",
+	"version": "15.11.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,15 +47,16 @@
 		"@agentclientprotocol/sdk": "0.22.1",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "15.10.11",
-		"@oh-my-pi/omp-stats": "15.10.11",
-		"@oh-my-pi/pi-agent-core": "15.10.11",
-		"@oh-my-pi/pi-ai": "15.10.11",
-		"@oh-my-pi/pi-catalog": "15.10.11",
-		"@oh-my-pi/pi-mnemopi": "15.10.11",
-		"@oh-my-pi/pi-natives": "15.10.11",
-		"@oh-my-pi/pi-tui": "15.10.11",
-		"@oh-my-pi/pi-utils": "15.10.11",
+		"@oh-my-pi/hashline": "15.11.0",
+		"@oh-my-pi/omp-stats": "15.11.0",
+		"@oh-my-pi/pi-agent-core": "15.11.0",
+		"@oh-my-pi/pi-ai": "15.11.0",
+		"@oh-my-pi/pi-catalog": "15.11.0",
+		"@oh-my-pi/pi-mnemopi": "15.11.0",
+		"@oh-my-pi/pi-natives": "15.11.0",
+		"@oh-my-pi/pi-tui": "15.11.0",
+		"@oh-my-pi/pi-utils": "15.11.0",
+		"@oh-my-pi/snapcompact": "15.11.0",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/scripts/bundle-dist.ts

@@ -51,25 +51,34 @@ async function cleanBundleOutputs(): Promise<void> {
 async function main(): Promise<void> {
 	const start = Bun.nanoseconds();
 	await cleanBundleOutputs();
-	await runCommand([
-		"bun",
-		"build",
-		"--target=bun",
-		"--outdir",
-		"dist",
-		"--minify-whitespace",
-		"--minify-syntax",
-		"--keep-names",
-		"--external",
-		"mupdf",
-		"--external",
-		"@oh-my-pi/pi-natives",
-		"--external",
-		"@huggingface/transformers",
-		"--define",
-		'process.env.PI_BUNDLED="true"',
-		"./src/cli.ts",
-	]);
+	// The npm bundle ships no stats dashboard sources or prebuilt dist/client,
+	// so embed the dashboard archive the same way compiled binaries do
+	// (scripts/build-binary.ts). Reset afterwards to keep the checked-in
+	// placeholder empty.
+	await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--generate"]);
+	try {
+		await runCommand([
+			"bun",
+			"build",
+			"--target=bun",
+			"--outdir",
+			"dist",
+			"--minify-whitespace",
+			"--minify-syntax",
+			"--keep-names",
+			"--external",
+			"mupdf",
+			"--external",
+			"@oh-my-pi/pi-natives",
+			"--external",
+			"@huggingface/transformers",
+			"--define",
+			'process.env.PI_BUNDLED="true"',
+			"./src/cli.ts",
+		]);
+	} finally {
+		await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--reset"]);
+	}
 	await ensureShebang();
 	const stat = await fs.stat(cliPath);
 	const elapsedMs = (Bun.nanoseconds() - start) / 1_000_000;

package/src/async/index.ts

@@ -1,2 +1 @@
 export * from "./job-manager";
-export * from "./support";

package/src/auto-thinking/classifier.ts

@@ -86,6 +86,7 @@ async function classifyOnline(input: string, deps: ClassifyDifficultyDeps): Prom
 			apiKey: deps.registry.resolver(model.provider, {
 				sessionId: deps.sessionId,
 				baseUrl: model.baseUrl,
+				modelId: model.id,
 			}),
 			maxTokens,
 			disableReasoning: true,

package/src/cli/args.ts

@@ -14,6 +14,7 @@ export interface Args {
 	allowHome?: boolean;
 	provider?: string;
 	model?: string;
+	config?: string[];
 	smol?: string;
 	slow?: string;
 	plan?: string;
@@ -111,6 +112,8 @@ export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { ty
 			result.allowHome = true;
 		} else if (arg === "--cwd" && i + 1 < args.length) {
 			result.cwd = args[++i];
+		} else if (arg === "--config" && i + 1 < args.length) {
+			result.config = [...(result.config ?? []), args[++i]];
 		} else if (arg === "--mode" && i + 1 < args.length) {
 			const mode = args[++i];
 			if (mode === "text" || mode === "json" || mode === "rpc" || mode === "acp" || mode === "rpc-ui") {

package/src/cli/gallery-cli.ts

@@ -69,7 +69,7 @@ function fakeToolFor(name: string, fixture: GalleryFixture | undefined): AgentTo
 	if (!fixture?.label && !fixture?.editMode && !fixture?.customRendered) return undefined;
 	const tool: Record<string, unknown> = { name, label: fixture.label ?? name, mode: fixture.editMode };
 	if (fixture.customRendered) {
-		const renderer = toolRenderers[name] as
+		const renderer = toolRenderers[fixture.renderer ?? name] as
 			| { renderCall?: unknown; renderResult?: unknown; mergeCallAndResult?: unknown; inline?: unknown }
 			| undefined;
 		if (renderer) {