jeopi-cli 16.6.12 → 16.6.14

package/dist/types/cli/messenger-cli.d.ts

@@ -6,5 +6,8 @@ export interface MessengerCommandArgs {
         config: string;
     };
 }
-/** Check is deliberately local-only: it never imports the SDK or starts a transport. */
+/**
+ * Check is deliberately local-only: it never starts a transport. The gateway process itself never loads the
+ * SDK; every conversation's AgentSession lives in its own session process.
+ */
 export declare function runMessengerCommand(cmd: MessengerCommandArgs): Promise<void>;

package/dist/types/cli/update-cli.d.ts

@@ -168,6 +168,15 @@ export declare function buildNpmInstallArgs(expectedVersion: string, nativeTag?:
 export declare function buildHomebrewUpdateArgs(force: boolean): string[];
 export declare function buildMiseUpgradeArgs(): string[];
 export declare function buildMiseForceInstallArgs(expectedVersion: string): string[];
+/**
+ * Update via package manager.
+ */
+export declare function updateViaBun(expectedVersion: string, runInstall?: (args: string[]) => Promise<{
+    exitCode: number;
+    stderr: {
+        toString(): string;
+    };
+}>): Promise<void>;
 /**
  * Run the update command.
  */

package/dist/types/messenger/activity.d.ts

@@ -0,0 +1,7 @@
+import type { AgentSessionEvent } from "../session/agent-session";
+import type { MessengerActivityReporter } from "./types";
+/**
+ * Derive one-line progress from session events: the model's declared tool intent (falling back to the
+ * tool name) and long-running lifecycle notices. Raw tool arguments, results and errors never surface.
+ */
+export declare function createMessengerActivityTracker(report: MessengerActivityReporter): (event: AgentSessionEvent) => void;

package/dist/types/messenger/gateway.d.ts

@@ -1,9 +1,20 @@
 import type { MessengerAdapter, MessengerConfig, MessengerMessage, MessengerReply } from "./types";
 /** Include the sender even in shared threads: remote histories must not cross users. */
 export declare function messengerConversationKey(message: MessengerMessage): string;
+/** Stable per-conversation route shared by the persisted session file and its session process. */
+export declare function messengerSessionRoute(cwd: string, message: MessengerMessage): string;
 export declare function isMessengerMessageAllowed(message: MessengerMessage, config: MessengerConfig): boolean;
 export interface MessengerGateway {
     run(signal: AbortSignal): Promise<void>;
     handle(message: MessengerMessage, signal?: AbortSignal): Promise<void>;
 }
-export declare function createMessengerGateway(config: MessengerConfig, adapters: MessengerAdapter[], reply: MessengerReply): MessengerGateway;
+export interface MessengerGatewayOptions {
+    /** Minimum spacing between in-place activity edits for one request. */
+    activityIntervalMs?: number;
+    /**
+     * Requests processed at once (default 1). Requests of one prepared conversation still answer and deliver in
+     * order; above 1 the reply implementation must accept concurrent turns for different conversations.
+     */
+    concurrency?: number;
+}
+export declare function createMessengerGateway(config: MessengerConfig, adapters: MessengerAdapter[], reply: MessengerReply, options?: MessengerGatewayOptions): MessengerGateway;

package/dist/types/messenger/session-pool.d.ts

@@ -0,0 +1,38 @@
+import type { MessengerSessionInbound, MessengerSessionOutbound } from "./session-worker";
+import type { MessengerConfig, MessengerReply } from "./types";
+/** Hidden CLI selector that re-enters jeopi as one conversation's session process (dispatched in `cli.ts`). */
+export declare const MESSENGER_SESSION_WORKER_ARG = "__omp_worker_messenger_session";
+/** One conversation's jeopi session process, as the pool sees it. */
+export interface MessengerSessionProcess {
+    send(message: MessengerSessionInbound): void;
+    onMessage(handler: (message: MessengerSessionOutbound) => void): () => void;
+    /** Settles when the process has exited for any reason. */
+    exited: Promise<unknown>;
+    kill(): void;
+}
+/** Spawn a real session process (the pool's default). */
+export declare function spawnMessengerSessionProcess(config: MessengerConfig): MessengerSessionProcess;
+/** `jeopi --smoke-test` probe: the session process loads its module graph and answers over IPC. */
+export declare function smokeTestMessengerSessionWorker({ timeoutMs, }?: {
+    timeoutMs?: number;
+}): Promise<void>;
+export interface MessengerSessionPoolOptions {
+    /** Resident session processes; at the limit a new conversation retires the least recently used idle one. */
+    maxProcesses?: number;
+    /** Idle time after which a conversation's process exits; its session file keeps the history. */
+    idleMs?: number;
+    /** Test seam: start one conversation's session process. */
+    spawn?: (config: MessengerConfig) => MessengerSessionProcess;
+}
+export interface MessengerSessionPool {
+    reply: MessengerReply;
+    close(): Promise<void>;
+}
+/**
+ * Give every conversation (a Discord thread or DM, a Telegram chat or topic, a Slack thread) its own jeopi
+ * session process: the first message starts it, later turns reuse it, and it exits after idling; the next
+ * message resumes the persisted session in a fresh process. Turns of one conversation run strictly in order
+ * (including retirement), while different conversations run concurrently. At most `maxProcesses` processes
+ * are resident: a new conversation waits for the least recently used idle one to retire, or for a slot.
+ */
+export declare function createMessengerSessionPool(config: MessengerConfig, options?: MessengerSessionPoolOptions): MessengerSessionPool;

package/dist/types/messenger/session-worker.d.ts

@@ -0,0 +1,49 @@
+import { createMessengerSessionBridge } from "./session";
+import type { MessengerConfig, MessengerMessage } from "./types";
+/** Gateway pool → session process. */
+export type MessengerSessionInbound = {
+    type: "ping";
+    id: string;
+} | {
+    type: "init";
+    id: string;
+    config: MessengerConfig;
+} | {
+    type: "turn";
+    id: string;
+    message: MessengerMessage;
+} | {
+    type: "abort";
+    id: string;
+} | {
+    type: "close";
+    id: string;
+};
+/** Session process → gateway pool. Failures carry no detail: tool output and provider errors stay here. */
+export type MessengerSessionOutbound = {
+    type: "pong";
+    id: string;
+} | {
+    type: "activity";
+    id: string;
+    text: string;
+} | {
+    type: "reply";
+    id: string;
+    text: string;
+} | {
+    type: "failed";
+    id: string;
+} | {
+    type: "closed";
+    id: string;
+};
+export interface MessengerSessionTransport {
+    send(message: MessengerSessionOutbound): void;
+    onMessage(handler: (message: MessengerSessionInbound) => void): () => void;
+}
+/**
+ * Serve one conversation's isolated AgentSession inside its own session process. The pool serializes turns, so
+ * the bridge sees one turn at a time and keeps its tool isolation and persisted history unchanged.
+ */
+export declare function startMessengerSessionWorker(transport: MessengerSessionTransport, createBridge?: typeof createMessengerSessionBridge): void;

package/dist/types/messenger/types.d.ts

@@ -16,12 +16,19 @@ export interface MessengerMessage {
         size: number;
     }[];
 }
+/** Report a short, human-readable description of the work in progress. */
+export type MessengerActivityReporter = (text: string) => void;
 export interface MessengerAdapter {
     platform: MessengerPlatform;
     start(onMessage: (message: MessengerMessage) => Promise<void>, signal: AbortSignal): Promise<void>;
     send(message: MessengerMessage, text: string, signal?: AbortSignal): Promise<void>;
     prepare?(message: MessengerMessage, signal?: AbortSignal): Promise<MessengerMessage>;
     status?(message: MessengerMessage, status: "processing" | "success" | "failure", signal?: AbortSignal): Promise<void>;
+    /**
+     * Show `text` (one sanitized line) as the request's single in-progress status, editing it in place on
+     * later calls; `undefined` removes it. The gateway serializes and throttles calls per request.
+     */
+    activity?(message: MessengerMessage, text: string | undefined, signal?: AbortSignal): Promise<void>;
 }
 export interface MessengerPlatformConfig {
     tokenEnv: string;
@@ -41,7 +48,7 @@ export interface MessengerTransportDeps {
     fetch?: typeof fetch;
     WebSocket?: typeof WebSocket;
 }
-export type MessengerReply = (message: MessengerMessage, signal: AbortSignal) => Promise<string>;
+export type MessengerReply = (message: MessengerMessage, signal: AbortSignal, onActivity?: MessengerActivityReporter) => Promise<string>;
 /** A partially initialized SDK must not be retried inside a live gateway. */
 export declare class MessengerFatalError extends Error {
     constructor();

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "jeopi-cli",
-	"version": "16.6.12",
+	"version": "16.6.14",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/akillness/jeopi",
 	"author": "Can Boluk",
@@ -57,17 +57,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"jeopi-hashline": "16.6.12",
-		"jeopi-stats": "16.6.12",
-		"jeopi-agent-core": "16.6.12",
-		"jeopi-ai": "16.6.12",
-		"jeopi-catalog": "16.6.12",
-		"jeopi-mnemopi": "16.6.12",
-		"jeopi-natives": "16.6.12",
-		"jeopi-tui": "16.6.12",
-		"jeopi-utils": "16.6.12",
-		"jeopi-wire": "16.6.12",
-		"jeopi-snapcompact": "16.6.12",
+		"jeopi-hashline": "16.6.14",
+		"jeopi-stats": "16.6.14",
+		"jeopi-agent-core": "16.6.14",
+		"jeopi-ai": "16.6.14",
+		"jeopi-catalog": "16.6.14",
+		"jeopi-mnemopi": "16.6.14",
+		"jeopi-natives": "16.6.14",
+		"jeopi-tui": "16.6.14",
+		"jeopi-utils": "16.6.14",
+		"jeopi-wire": "16.6.14",
+		"jeopi-snapcompact": "16.6.14",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/cli/messenger-cli.ts

@@ -1,6 +1,10 @@
 import { loadMessengerConfig, validateMessengerEnvironment } from "../messenger/config";
-import type { MessengerSessionBridge } from "../messenger/session";
-import { type MessengerAdapter, type MessengerConfig, MessengerFatalError } from "../messenger/types";
+import { createDiscordAdapter } from "../messenger/discord";
+import { createMessengerGateway } from "../messenger/gateway";
+import { createMessengerSessionPool, type MessengerSessionPool } from "../messenger/session-pool";
+import { createSlackAdapter } from "../messenger/slack";
+import { createTelegramAdapter } from "../messenger/telegram";
+import type { MessengerAdapter, MessengerConfig } from "../messenger/types";
 
 export const MESSENGER_ACTIONS = ["check", "run"] as const;
 export type MessengerAction = (typeof MESSENGER_ACTIONS)[number];
@@ -9,7 +13,13 @@ export interface MessengerCommandArgs {
 	flags: { config: string };
 }
 
-/** Check is deliberately local-only: it never imports the SDK or starts a transport. */
+/** Conversations answered at once; each conversation runs in its own session process. */
+const MESSENGER_CONCURRENCY = 4;
+
+/**
+ * Check is deliberately local-only: it never starts a transport. The gateway process itself never loads the
+ * SDK; every conversation's AgentSession lives in its own session process.
+ */
 export async function runMessengerCommand(cmd: MessengerCommandArgs): Promise<void> {
 	if (!MESSENGER_ACTIONS.includes(cmd.action)) throw new Error("Unknown messenger action");
 	if (!cmd.flags.config) throw new Error("Messenger requires --config <file>");
@@ -38,35 +48,23 @@ export async function runMessengerCommand(cmd: MessengerCommandArgs): Promise<vo
 	const stop = (): void => controller.abort();
 	process.once("SIGINT", stop);
 	process.once("SIGTERM", stop);
-	let bridge: MessengerSessionBridge | undefined;
+	let pool: MessengerSessionPool | undefined;
 	let failure: Error | undefined;
 	try {
-		const [{ createMessengerSessionBridge }, { createMessengerGateway }, telegram, discord, slack] =
-			await Promise.all([
-				import("../messenger/session"),
-				import("../messenger/gateway"),
-				import("../messenger/telegram"),
-				import("../messenger/discord"),
-				import("../messenger/slack"),
-			]);
-		if (controller.signal.aborted) return;
-		bridge = createMessengerSessionBridge(config);
+		pool = createMessengerSessionPool(config);
 		const adapters: MessengerAdapter[] = [];
-		if (config.platforms.telegram) adapters.push(telegram.createTelegramAdapter(config.platforms.telegram));
-		if (config.platforms.discord) adapters.push(discord.createDiscordAdapter(config.platforms.discord));
-		if (config.platforms.slack) adapters.push(slack.createSlackAdapter(config.platforms.slack));
-		const gateway = createMessengerGateway(config, adapters, bridge.reply);
+		if (config.platforms.telegram) adapters.push(createTelegramAdapter(config.platforms.telegram));
+		if (config.platforms.discord) adapters.push(createDiscordAdapter(config.platforms.discord));
+		if (config.platforms.slack) adapters.push(createSlackAdapter(config.platforms.slack));
+		const gateway = createMessengerGateway(config, adapters, pool.reply, { concurrency: MESSENGER_CONCURRENCY });
 		process.stdout.write(`Starting messenger: ${platforms.join(", ")}. Press Ctrl+C to stop.\n`);
 		await gateway.run(controller.signal);
-	} catch (error) {
-		failure =
-			error instanceof MessengerFatalError
-				? error
-				: new Error("Messenger gateway failed; check local configuration and provider access");
+	} catch {
+		failure = new Error("Messenger gateway failed; check local configuration and provider access");
 	} finally {
 		controller.abort();
 		try {
-			await bridge?.close();
+			await pool?.close();
 		} catch {
 			failure ??= new Error("Messenger session shutdown failed");
 		} finally {

package/src/cli/update-cli.ts

@@ -972,12 +972,22 @@ export function buildMiseForceInstallArgs(expectedVersion: string): string[] {
 /**
  * Update via package manager.
  */
-async function updateViaBun(expectedVersion: string): Promise<void> {
+export async function updateViaBun(
+	expectedVersion: string,
+	runInstall: (args: string[]) => Promise<{ exitCode: number; stderr: { toString(): string } }> = async args =>
+		await $`bun ${args}`.nothrow(),
+): Promise<void> {
 	console.log(chalk.dim("Updating via bun..."));
 	const args = buildBunInstallArgs(expectedVersion);
-	const result = await $`bun ${args}`.nothrow();
+	const result = await runInstall(args);
 	if (result.exitCode !== 0) {
-		throw new Error(`bun install failed with exit code ${result.exitCode}`);
+		const guidance =
+			/^error: empty dependency name \(in "dependencies"\)\r?\n\s+at .+[\\/]package\.json:\d+:\d+\s*$/m.test(
+				Bun.stripANSI(result.stderr.toString()),
+			)
+				? "\nBack up the package.json shown in Bun's diagnostic above, then remove only the empty-name entry from its dependencies and retry the update."
+				: "";
+		throw new Error(`bun install failed with exit code ${result.exitCode}${guidance}`);
 	}
 
 	await printVerification(expectedVersion);

package/src/cli.ts

@@ -63,6 +63,9 @@ async function runSmokeTest(): Promise<void> {
 	const { smokeTestTtsWorker } = await import("./tts/tts-client");
 	const { smokeTestMnemopiEmbedWorker } = await import("./mnemopi/embed-client");
 	const { smokeTestJsEvalWorker } = await import("./eval/js/context-manager");
+	// Dynamic like its siblings: `session-pool` imports `jeopi-utils`, whose env module loads `.env` at import
+	// time and must not run before profile bootstrap (see the note above `showHelp`).
+	const { smokeTestMessengerSessionWorker } = await import("./messenger/session-pool");
 	await smokeTestSyncWorker();
 
 	const statsServer = await startServer(0);
@@ -82,6 +85,7 @@ async function runSmokeTest(): Promise<void> {
 	await smokeTestJsEvalWorker();
 	await smokeTestTtsWorker();
 	await smokeTestMnemopiEmbedWorker();
+	await smokeTestMessengerSessionWorker();
 	process.stdout.write("smoke-test: ok\n");
 }
 
@@ -92,6 +96,8 @@ const JS_EVAL_WORKER_ARG = "__omp_worker_js_eval";
 const STT_WORKER_ARG = "__omp_worker_stt";
 const TTS_WORKER_ARG = "__omp_worker_tts";
 const MNEMOPI_EMBED_WORKER_ARG = "__omp_worker_mnemopi_embed";
+/** Must match `MESSENGER_SESSION_WORKER_ARG` in `messenger/session-pool.ts`, which this entry cannot import early. */
+const MESSENGER_SESSION_WORKER_ARG = "__omp_worker_messenger_session";
 
 async function runWorkerEntrypoint(arg: string | undefined): Promise<boolean> {
 	if (arg === TINY_WORKER_ARG) {
@@ -152,6 +158,13 @@ async function runWorkerEntrypoint(arg: string | undefined): Promise<boolean> {
 		await runIpcSubprocessWorker(startMnemopiEmbedWorker);
 		return true;
 	}
+	if (arg === MESSENGER_SESSION_WORKER_ARG) {
+		// Dynamic: the session process loads the agent SDK only after profile bootstrap and worker dispatch;
+		// a static import would load it into every CLI start and every other worker kind.
+		const { startMessengerSessionWorker } = await import("./messenger/session-worker");
+		await runIpcSubprocessWorker(startMessengerSessionWorker);
+		return true;
+	}
 	return false;
 }
 

package/src/extensibility/plugins/legacy-pi-bundled-keys.ts

@@ -264,6 +264,7 @@ export const BUNDLED_PI_REGISTRY_KEYS: ReadonlySet<string> = new Set([
 	"@oh-my-pi/pi-coding-agent/cli/grep-cli",
 	"@oh-my-pi/pi-coding-agent/cli/grievances-cli",
 	"@oh-my-pi/pi-coding-agent/cli/initial-message",
+	"@oh-my-pi/pi-coding-agent/cli/messenger-cli",
 	"@oh-my-pi/pi-coding-agent/cli/models-cli",
 	"@oh-my-pi/pi-coding-agent/cli/plugin-cli",
 	"@oh-my-pi/pi-coding-agent/cli/profile-alias",
@@ -313,6 +314,7 @@ export const BUNDLED_PI_REGISTRY_KEYS: ReadonlySet<string> = new Set([
 	"@oh-my-pi/pi-coding-agent/commands/install",
 	"@oh-my-pi/pi-coding-agent/commands/join",
 	"@oh-my-pi/pi-coding-agent/commands/launch",
+	"@oh-my-pi/pi-coding-agent/commands/messenger",
 	"@oh-my-pi/pi-coding-agent/commands/models",
 	"@oh-my-pi/pi-coding-agent/commands/plugin",
 	"@oh-my-pi/pi-coding-agent/commands/read",

package/src/extensibility/plugins/legacy-pi-bundled-registry.ts

@@ -238,6 +238,7 @@ import * as bundledPiCodingAgentCliGcCli from "jeopi-cli/cli/gc-cli";
 import * as bundledPiCodingAgentCliGrepCli from "jeopi-cli/cli/grep-cli";
 import * as bundledPiCodingAgentCliGrievancesCli from "jeopi-cli/cli/grievances-cli";
 import * as bundledPiCodingAgentCliInitialMessage from "jeopi-cli/cli/initial-message";
+import * as bundledPiCodingAgentCliMessengerCli from "jeopi-cli/cli/messenger-cli";
 import * as bundledPiCodingAgentCliModelsCli from "jeopi-cli/cli/models-cli";
 import * as bundledPiCodingAgentCliPluginCli from "jeopi-cli/cli/plugin-cli";
 import * as bundledPiCodingAgentCliProfileAlias from "jeopi-cli/cli/profile-alias";
@@ -274,6 +275,7 @@ import * as bundledPiCodingAgentCommandsGrievances from "jeopi-cli/commands/grie
 import * as bundledPiCodingAgentCommandsInstall from "jeopi-cli/commands/install";
 import * as bundledPiCodingAgentCommandsJoin from "jeopi-cli/commands/join";
 import * as bundledPiCodingAgentCommandsLaunch from "jeopi-cli/commands/launch";
+import * as bundledPiCodingAgentCommandsMessenger from "jeopi-cli/commands/messenger";
 import * as bundledPiCodingAgentCommandsModels from "jeopi-cli/commands/models";
 import * as bundledPiCodingAgentCommandsPlugin from "jeopi-cli/commands/plugin";
 import * as bundledPiCodingAgentCommandsRead from "jeopi-cli/commands/read";
@@ -1591,6 +1593,9 @@ export const BUNDLED_PI_REGISTRY: Readonly<Record<string, Readonly<Record<string
 	"@oh-my-pi/pi-coding-agent/cli/initial-message": bundledPiCodingAgentCliInitialMessage as unknown as Readonly<
 		Record<string, unknown>
 	>,
+	"@oh-my-pi/pi-coding-agent/cli/messenger-cli": bundledPiCodingAgentCliMessengerCli as unknown as Readonly<
+		Record<string, unknown>
+	>,
 	"@oh-my-pi/pi-coding-agent/cli/models-cli": bundledPiCodingAgentCliModelsCli as unknown as Readonly<
 		Record<string, unknown>
 	>,
@@ -1727,6 +1732,9 @@ export const BUNDLED_PI_REGISTRY: Readonly<Record<string, Readonly<Record<string
 	"@oh-my-pi/pi-coding-agent/commands/launch": bundledPiCodingAgentCommandsLaunch as unknown as Readonly<
 		Record<string, unknown>
 	>,
+	"@oh-my-pi/pi-coding-agent/commands/messenger": bundledPiCodingAgentCommandsMessenger as unknown as Readonly<
+		Record<string, unknown>
+	>,
 	"@oh-my-pi/pi-coding-agent/commands/models": bundledPiCodingAgentCommandsModels as unknown as Readonly<
 		Record<string, unknown>
 	>,