jeopi-cli 16.6.13 → 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/messenger/gateway.d.ts

@@ -1,6 +1,8 @@
 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>;
@@ -9,5 +11,10 @@ export interface 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/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "jeopi-cli",
-	"version": "16.6.13",
+	"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.13",
-		"jeopi-stats": "16.6.13",
-		"jeopi-agent-core": "16.6.13",
-		"jeopi-ai": "16.6.13",
-		"jeopi-catalog": "16.6.13",
-		"jeopi-mnemopi": "16.6.13",
-		"jeopi-natives": "16.6.13",
-		"jeopi-tui": "16.6.13",
-		"jeopi-utils": "16.6.13",
-		"jeopi-wire": "16.6.13",
-		"jeopi-snapcompact": "16.6.13",
+		"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.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;
 }