jeo-code 0.12.10 → 0.12.11

package/src/commands/messenger.ts

@@ -7,7 +7,7 @@ import { loadMessengerConfig, validateMessengerEnvironment } from "../messenger/
 import { createDiscordAdapter } from "../messenger/discord";
 import { setupDiscordMessenger } from "../messenger/discord-setup";
 import { messengerArtifactPrompt } from "../messenger/artifacts";
-import { createMessengerGateway, messengerSessionRoute } from "../messenger/gateway";
+import { createMessengerGateway, messengerSessionRoute, messengerConversationKey } from "../messenger/gateway";
 import { createMessengerSessionPool } from "../messenger/session-pool";
 import { createSlackAdapter } from "../messenger/slack";
 import { createTelegramAdapter } from "../messenger/telegram";
@@ -57,6 +57,10 @@ function terminalIO() {
 }
 
 function routeUuid(config: MessengerConfig, message: Parameters<MessengerReply>[0]): string {
+	if (config.independentSessions) {
+		const hex = new Bun.CryptoHasher("sha256").update(JSON.stringify([config.cwd, messengerConversationKey(message), message.messageId])).digest("hex");
+		return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-a${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+	}
 	const hex = messengerSessionRoute(config.cwd, message);
 	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-a${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
 }

package/src/commands/notify.ts

@@ -15,7 +15,6 @@ interface NotifyOptions {
 }
 interface Flags {
   provider: Provider;
-  token?: string;
   tokenEnv?: string;
   appTokenEnv?: string;
   chatId?: string;
@@ -27,13 +26,13 @@ function parseFlags(args: string[]): Flags {
   const out: Flags = { provider: "telegram" };
   for (let i = 0; i < args.length; i++) {
     const flag = args[i];
+    if (flag === "--token") throw new Error("Raw --token credentials are not supported; use --token-env NAME");
     const value = args[++i];
     if (!value || value.startsWith("--")) throw new Error("Missing value for notify option (use --token-env NAME for credentials)");
     if (flag === "--provider" || flag === "--platform") {
       if (value !== "telegram" && value !== "discord" && value !== "slack") throw new Error("Provider must be telegram, discord or slack");
       out.provider = value;
-    } else if (flag === "--token") out.token = value;
-    else if (flag === "--token-env") out.tokenEnv = value;
+    } else if (flag === "--token-env") out.tokenEnv = value;
     else if (flag === "--app-token-env") out.appTokenEnv = value;
     else if (flag === "--chat-id") out.chatId = value;
     else if (flag === "--channel-id") out.channelId = value;
@@ -73,12 +72,12 @@ async function verifySlack(api: SlackApi, channelId: string): Promise<void> {
 
 async function runSetup(flags: Flags, opts: NotifyOptions): Promise<void> {
   const envName = flags.tokenEnv ?? `JEO_${flags.provider.toUpperCase()}_BOT_TOKEN`;
-  let token = flags.token ?? process.env[envName]?.trim();
+  let token = process.env[envName]?.trim();
   if (!token) {
     const name = await question(`Set the bot token in an environment variable, then enter its NAME (default ${envName}): `, opts);
     token = process.env[name || envName]?.trim();
   }
-  if (!token) throw new Error(`Bot token environment variable is empty; use --token-env NAME (preferred over --token)`);
+  if (!token) throw new Error("Bot token environment variable is empty; use --token-env NAME");
   const existing = (await readGlobalConfig()).notifications;
   let allowedUserIds = flags.allowedUserIds;
   if (flags.provider === "slack") {
@@ -237,7 +236,7 @@ export async function runNotifyCommand(args: string[], opts: NotifyOptions = {})
   } catch (error) {
     // Only emit our known configuration/API errors, never fetch URLs or token-bearing bodies.
     const message = error instanceof Error ? error.message : "request failed";
-    const safe = /^(Missing |Unknown notify|Provider |Allowed user|Telegram |Discord |Slack |Bot token|Missing setup|A daemon|Notification lock recovery|Usage:)/.test(message) && !message.includes("https:") && !message.includes("http:");
+    const safe = /^(Missing |Unknown notify|Raw --token|Provider |Allowed user|Telegram |Discord |Slack |Bot token|Missing setup|A daemon|Notification lock recovery|Usage:)/.test(message) && !message.includes("https:") && !message.includes("http:");
     console.error(`Notification ${sub} failed: ${safe ? message : "API or storage request failed; check credentials, connectivity and permissions"}${(error instanceof DiscordApiError || error instanceof SlackApiError) && error.status ? ` (HTTP ${error.status})` : ""}`);
     process.exitCode = 1;
   }

package/src/commands/skills.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { SKILLS, getSkillFrom, formatSkill, loadSkills, skillDirs, bundledSkillFileContent, userSkillsDir } from "../skills/catalog";
+import { inventorySkillConflicts } from "../agent/skill-router";
 import { getLocalJeoDir } from "../agent/state";
 import { appendSkillLesson, evalSkillLessons, type SkillLesson } from "../agent/skill-lessons";
 
@@ -221,6 +222,14 @@ export async function runSkillsCommand(args: string[] = []): Promise<void> {
       console.log("Install/inspect bundled defaults: 'jeo skills sync' (preserve local) · '--check' (drift report) · '--force' (overwrite local)");
       console.log("Discovery dirs (later wins on name clash; JEO_SKILLS_DIR adds more):");
       for (const d of skillDirs(cwd)) console.log(`  ${d}`);
+      const conflicts = inventorySkillConflicts(skills);
+      if (conflicts.length > 0) {
+        console.log("\nECC Single-Harness duplicate identity warnings:");
+        for (const c of conflicts) {
+          console.log(`  ! Duplicate skill '${c.normalized}' installed across multiple distinct paths:`);
+          for (const p of c.paths) console.log(`      ${p}`);
+        }
+      }
       console.log("");
     }
     return;

package/src/commands/team.ts

@@ -168,8 +168,14 @@ export interface TeamEngineOptions {
    *  write/edit/bash fails the task instead of merely warning (round-11). */
   strictMutations?: boolean;
 }
+export interface TeamEngineResult {
+  ok: boolean;
+  reason?: string;
+  /** True when a delegated child may have changed workspace state before settling. */
+  mutationMayHaveOccurred?: boolean;
+}
 
-export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok: boolean; reason?: string }> {
+export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<TeamEngineResult> {
   const cwd = opts.cwd ?? process.cwd();
 
   const log = (msg?: any) => {
@@ -339,6 +345,7 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
 
     await writeWorkflowState("team", teamState, cwd);
     const renderOpts: RalphRenderOptions = { color: !!process.stdout.isTTY, indexed: true };
+    let mutationMayHaveOccurred = false;
     for (const line of formatRalphTodoGuide(tasks, activeStepIndex(tasks.length, teamState.pending_tasks), teamState.completed_tasks ?? [], renderOpts)) log(line);
 
     while (teamState.pending_tasks && teamState.pending_tasks.length > 0) {
@@ -384,20 +391,22 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
         });
 
         if (opts.signal?.aborted) {
-          return { ok: false, reason: "aborted" };
+          return { ok: false, reason: "aborted", ...(mutationMayHaveOccurred ? { mutationMayHaveOccurred: true } : {}) };
         }
 
         if (groupResult.ok) {
+          mutationMayHaveOccurred ||= groupResult.mutationMayHaveOccurred === true;
           teamState.completed_tasks = [...(teamState.completed_tasks ?? []), ...groupSteps.map(s => s.name)];
           teamState.pending_tasks = teamState.pending_tasks.slice(groupSteps.length);
           await writeWorkflowState("team", teamState, cwd);
           log(`${categoryBadge("done")} Completed parallel group: ${groupSteps.map(s => `"${s.name}"`).join(", ")}`);
         } else {
+          mutationMayHaveOccurred ||= groupResult.mutationMayHaveOccurred === true;
           teamState.current_phase = "failed";
           teamState.failed_task = groupResult.failedTaskName;
           await writeWorkflowState("team", teamState, cwd);
           log(`${categoryBadge("error")} Failed on parallel group step: "${groupResult.failedTaskName}". Halting execution.`);
-          return { ok: false, reason: `Failed on task: "${groupResult.failedTaskName}"` };
+          return { ok: false, reason: `Failed on task: "${groupResult.failedTaskName}"`, ...(mutationMayHaveOccurred ? { mutationMayHaveOccurred: true } : {}) };
         }
         continue;
       }
@@ -409,7 +418,7 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
         opts.onProgress({ skill: "team", phase: "executing", detail: `Current task: ${currentTask}` });
       }
 
-      const success = await executeTaskWithAgent({
+      const taskResult = await executeTaskWithAgent({
         task: currentTask,
         tasks,
         activeIndex,
@@ -419,12 +428,13 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
         strictMutations: opts.strictMutations ?? false,
         log,
       });
+      mutationMayHaveOccurred ||= taskResult.mutationMayHaveOccurred === true;
 
       if (opts.signal?.aborted) {
-        return { ok: false, reason: "aborted" };
+        return { ok: false, reason: "aborted", ...(mutationMayHaveOccurred ? { mutationMayHaveOccurred: true } : {}) };
       }
 
-      if (success) {
+      if (taskResult.ok) {
         teamState.completed_tasks = [...(teamState.completed_tasks ?? []), currentTask];
         teamState.pending_tasks = teamState.pending_tasks.slice(1);
         await writeWorkflowState("team", teamState, cwd);
@@ -436,7 +446,7 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
         teamState.failed_task = currentTask;
         await writeWorkflowState("team", teamState, cwd);
         log(`${categoryBadge("error")} Failed on task: "${currentTask}". Halting execution.`);
-        return { ok: false, reason: `Failed on task: "${currentTask}"` };
+        return { ok: false, reason: `Failed on task: "${currentTask}"`, ...(mutationMayHaveOccurred ? { mutationMayHaveOccurred: true } : {}) };
       }
     }
 
@@ -450,7 +460,7 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
         opts.onProgress({ skill: "team", phase: "complete" });
       }
     }
-    return { ok: true };
+    return { ok: true, ...(mutationMayHaveOccurred ? { mutationMayHaveOccurred: true } : {}) };
   } finally {
     await releaseLock();
   }
@@ -464,7 +474,11 @@ export async function runTeamCommand(args: string[] = []): Promise<void> {
   }
 }
 
-async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: string; roleId?: string; strictMutations?: boolean; log: (line: string) => void }): Promise<boolean> {
+interface TeamTaskResult {
+  ok: boolean;
+  mutationMayHaveOccurred?: boolean;
+}
+async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: string; roleId?: string; strictMutations?: boolean; log: (line: string) => void }): Promise<TeamTaskResult> {
   const log = ctx.log;
   const config = await readGlobalConfig();
   const role = getSubagentRole(ctx.roleId, config) ?? defaultSubagentRole();
@@ -476,25 +490,33 @@ async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: str
   const projectContext = await loadProjectContext(ctx.cwd);
 
   // `jeo team` now runs every step through the SAME execution core as the `task`/
-  // `subagent` tools (`runSubagentOnce`) — one way a jeo-code subagent runs,
-  // whether launched interactively, in a fan-out batch, detached, or as a team
-  // plan step. This gets team plan steps the same fenced-report protection
-  // (prompt-injection-safe) and done-reason contract validation the interactive
-  // tools already had, instead of a second hand-rolled copy of that logic.
-  const result = await runSubagentOnce(role, buildRalphSubagentPrompt(ctx), "", ctx.cwd, {
-    config,
-    projectContext,
-    onEvent: ev => {
-      if (ev.kind === "step") {
-        log(formatRalphStreamEvent("step", ev.detail ?? `${role.title} thinking ${ev.step ?? "?"}/${ev.maxSteps ?? maxSteps}`, renderOpts));
-      } else if (ev.kind === "tool") {
-        const suffix = ev.summary ? ` — ${ev.summary}` : "";
-        log(formatRalphStreamEvent(ev.success ? "complete" : "error", `tool ${ev.detail}${suffix}`, renderOpts));
-      }
-    },
-  });
+  // `subagent` tools — one way a jeo-code subagent runs, whether launched
+  // interactively, in a fan-out batch, detached, or as a team plan step.
+  let result: SubagentRunResult;
+  try {
+    result = await runSubagentOnce(role, buildRalphSubagentPrompt(ctx), "", ctx.cwd, {
+      config,
+      projectContext,
+      onEvent: ev => {
+        if (ev.kind === "step") {
+          log(formatRalphStreamEvent("step", ev.detail ?? `${role.title} thinking ${ev.step ?? "?"}/${ev.maxSteps ?? maxSteps}`, renderOpts));
+        } else if (ev.kind === "tool") {
+          const suffix = ev.summary ? ` — ${ev.summary}` : "";
+          log(formatRalphStreamEvent(ev.success ? "complete" : "error", `tool ${ev.detail}${suffix}`, renderOpts));
+        }
+      },
+    });
+  } catch (error: unknown) {
+    const explicitSignal = typeof error === "object" && error !== null && "mutationMayHaveOccurred" in error && error.mutationMayHaveOccurred === true;
+    const message = error instanceof Error ? error.message : String(error);
+    log(formatRalphStreamEvent("error", message, renderOpts));
+    return { ok: false, ...(explicitSignal || !role.readOnly ? { mutationMayHaveOccurred: true } : {}) };
+  }
 
-  return evaluateSubagentResult(result, role, ctx.strictMutations ?? false, log, renderOpts);
+  return {
+    ok: evaluateSubagentResult(result, role, ctx.strictMutations ?? false, log, renderOpts),
+    ...(result.mutationMayHaveOccurred ? { mutationMayHaveOccurred: true } : {}),
+  };
 }
 
 /**
@@ -543,23 +565,14 @@ function evaluateSubagentResult(
     return false;
   }
 
-  // Round-8: a mutating role finished without a successful file mutation — the
-  // task may be legitimately read-only, but its "Changed Files:" claim is
-  // unverified. bash is tracked apart: an only-bash run MIGHT have mutated.
+  // A mutating role's changed-files claim needs an observed workspace mutation.
+  // Bash is separate because it may or may not have changed files.
   if (!role.readOnly && result.fileMutations === 0) {
     const msg = result.bashRuns === 0
-      ? `${role.title} completed WITHOUT any successful write/edit/bash — treat its changed-files claim as unverified.`
-      : `${role.title} completed with only bash (no write/edit) — verify its changed-files claim independently.`;
-    // Round-11: under --strict-mutations, a mutating role that took NO action at
-    // all (no write/edit/bash) is a hard failure — an empty run must not pass as
-    // a completed task. bash-only stays advisory to avoid penalizing shell edits.
-    const hardFail = strictMutations && result.bashRuns === 0;
-    // Round-12: separate the tones so a passing advisory run doesn't masquerade
-    // as a stream:error — only a real hard-fail is red; an advisory note is warn.
-    log(formatRalphStreamEvent(hardFail ? "error" : "warn", msg, renderOpts));
-    if (hardFail) {
-      return false;
-    }
+      ? `${role.title} completed WITHOUT any successful workspace mutation or bash call — treat its changed-files claim as unverified.`
+      : `${role.title} completed without a successful workspace mutation (only bash ran) — verify its changed-files claim independently.`;
+    log(formatRalphStreamEvent(strictMutations ? "error" : "warn", msg, renderOpts));
+    if (strictMutations && result.bashRuns === 0) return false;
   }
 
   // Surface the subagent's full report (header + step trace + fenced reason +
@@ -610,7 +623,7 @@ async function runParallelGroup(
     log: (line: string) => void;
     slug: string;
   },
-): Promise<{ ok: true } | { ok: false; failedTaskName: string }> {
+): Promise<{ ok: true; mutationMayHaveOccurred?: boolean } | { ok: false; failedTaskName: string; mutationMayHaveOccurred?: boolean }> {
   const { cwd, teamCfg, tasks, completed, strictMutations, log, slug } = ctx;
   const renderOpts: RalphRenderOptions = { color: !!process.stdout.isTTY, indexed: true };
 
@@ -654,16 +667,22 @@ async function runParallelGroup(
           }
         },
       });
-      // Capture the FULL SubagentRunResult (doneReason/fileMutations/etc.) before
-      // collapsing it to the plain ToolResult shape SubagentRegistry stores.
+      // Capture the FULL SubagentRunResult before collapsing it to the plain
+      // ToolResult shape SubagentRegistry stores, including mutation evidence.
       resultsByIndex.set(step.index, result);
-      return { success: result.success, output: result.output, error: result.error };
-    });
+      return {
+        success: result.success,
+        output: result.output,
+        error: result.error,
+        mutationMayHaveOccurred: result.mutationMayHaveOccurred,
+      };
+    }, { readOnly: role.readOnly });
     idByIndex.set(step.index, record.id);
   }
 
   // No timeout — team runs can take as long as needed.
   await registry.awaitIds([...idByIndex.values()]);
+  const registryMutation = registry.list().some(record => record.mutationMayHaveOccurred === true);
 
   // Evaluate + commit each successful worktree, IN ARRAY ORDER (not completion
   // order). Any failure stops the whole group immediately: no merges happen,
@@ -674,12 +693,12 @@ async function runParallelGroup(
     const wt = worktreeByIndex.get(step.index)!;
     if (!result) {
       log(formatRalphStreamEvent("error", `[${step.name}] subagent produced no result`, renderOpts));
-      return { ok: false, failedTaskName: step.name };
+      return { ok: false, failedTaskName: step.name, ...(registryMutation ? { mutationMayHaveOccurred: true } : {}) };
     }
     const success = evaluateSubagentResult(result, role, strictMutations, log, renderOpts);
     if (!success) {
       log(`${categoryBadge("error")} Parallel group step "${step.name}" failed — its worktree (${wt.path}) and the OTHER group worktrees are left in place for inspection; nothing was merged.`);
-      return { ok: false, failedTaskName: step.name };
+      return { ok: false, failedTaskName: step.name, ...(registryMutation || result.mutationMayHaveOccurred ? { mutationMayHaveOccurred: true } : {}) };
     }
     // An empty diff (read-only role, or a no-op) needs no commit — skip it for
     // the merge step below without treating it as an error.
@@ -687,12 +706,12 @@ async function runParallelGroup(
       const add = runGitSync(wt.path, ["add", "-A"]);
       if (!add.ok) {
         log(`${categoryBadge("error")} Failed to stage changes in worktree ${wt.path} for step "${step.name}": ${add.stderr.trim()}`);
-        return { ok: false, failedTaskName: step.name };
+        return { ok: false, failedTaskName: step.name, ...(registryMutation ? { mutationMayHaveOccurred: true } : {}) };
       }
       const commit = runGitSync(wt.path, ["commit", "-m", step.name]);
       if (!commit.ok) {
         log(`${categoryBadge("error")} Failed to commit changes in worktree ${wt.path} for step "${step.name}": ${commit.stderr.trim()}`);
-        return { ok: false, failedTaskName: step.name };
+        return { ok: false, failedTaskName: step.name, ...(registryMutation ? { mutationMayHaveOccurred: true } : {}) };
       }
     }
   }
@@ -710,7 +729,7 @@ async function runParallelGroup(
         `the merge was aborted automatically (no changes were auto-resolved). Resolve manually: ` +
         `cd ${wt.path} to inspect the change, then run 'git merge ${wt.branch}' yourself from ${cwd}.\n${(merge.stderr + merge.stdout).trim()}`,
       );
-      return { ok: false, failedTaskName: step.name };
+      return { ok: false, failedTaskName: step.name, ...(registryMutation ? { mutationMayHaveOccurred: true } : {}) };
     }
     log(`${categoryBadge("done")} Merged step "${step.name}" (branch ${wt.branch}) into the current branch.`);
   }
@@ -725,5 +744,5 @@ async function runParallelGroup(
     }
   }
 
-  return { ok: true };
+  return { ok: true, ...(registryMutation ? { mutationMayHaveOccurred: true } : {}) };
 }

package/src/messenger/config.ts

@@ -61,9 +61,11 @@ export function resolveMessengerToken(
 	return undefined;
 }
 
+export const DEFAULT_MESSENGER_TOOLS = ["read", "find", "search", "write", "edit", "bash", "computer"];
+
 export function parseMessengerConfig(value: unknown, baseDir: string): MessengerConfig {
 	const input = object(value, "Messenger config");
-	keys(input, ["cwd", "sessionDir", "toolNames", "platforms"], "Messenger config");
+	keys(input, ["cwd", "sessionDir", "toolNames", "platforms", "independentSessions"], "Messenger config");
 	const platformsInput = object(input.platforms, "platforms");
 	keys(platformsInput, PLATFORMS, "platforms");
 	if (Object.keys(platformsInput).length === 0) throw new Error("At least one messenger platform is required");
@@ -98,7 +100,7 @@ export function parseMessengerConfig(value: unknown, baseDir: string): Messenger
 		}
 		platforms[platform] = config;
 	}
-	const toolNames = input.toolNames === undefined ? [] : input.toolNames;
+	const toolNames = input.toolNames === undefined ? DEFAULT_MESSENGER_TOOLS : input.toolNames;
 	if (
 		!Array.isArray(toolNames) ||
 		toolNames.some(name => typeof name !== "string" || !Object.hasOwn(TOOLS, name)) ||
@@ -106,6 +108,7 @@ export function parseMessengerConfig(value: unknown, baseDir: string): Messenger
 	) {
 		throw new Error("toolNames must be a unique list drawn from read, grep, glob, find, search, bash, edit, write, computer");
 	}
+	const independentSessions = input.independentSessions !== undefined ? Boolean(input.independentSessions) : true;
 	return {
 		cwd: path.resolve(baseDir, input.cwd === undefined ? "." : string(input.cwd, "cwd")),
 		sessionDir: path.resolve(
@@ -114,6 +117,7 @@ export function parseMessengerConfig(value: unknown, baseDir: string): Messenger
 		),
 		toolNames: [...toolNames] as string[],
 		platforms,
+		independentSessions,
 	};
 }
 

package/src/messenger/discord-setup.ts

@@ -510,11 +510,13 @@ export async function setupDiscordMessenger(
 
 	const discord: Record<string, unknown> = { ...previous, tokenEnv, allowedUserIds: userIds, allowedChannelIds };
 	if (options.artifacts) discord.artifactDir = "./artifacts";
+	const defaultTools = ["read", "find", "search", "write", "edit", "bash", "computer"];
 	const config = {
 		...existing,
 		cwd: str(existing?.cwd) ?? "./workspace",
 		sessionDir: str(existing?.sessionDir) ?? "./sessions",
-		toolNames: options.toolNames ?? (Array.isArray(existing?.toolNames) ? existing.toolNames : []),
+		toolNames: options.toolNames ?? (Array.isArray(existing?.toolNames) ? existing.toolNames : defaultTools),
+		independentSessions: existing?.independentSessions !== undefined ? Boolean(existing.independentSessions) : true,
 		platforms: { ...platforms, discord },
 	};
 	for (const relative of [config.cwd, config.sessionDir, discord.artifactDir]) {

package/src/messenger/discord.ts

@@ -541,7 +541,11 @@ export function createDiscordAdapter(
 				try {
 					await messengerFetchJson(
 						`${messages}/${encodeURIComponent(statusId)}`,
-						{ method: "DELETE", headers: headers() },
+						{
+							method: "PATCH",
+							headers: headers(),
+							body: JSON.stringify({ content: "✅ Complete", allowed_mentions: { parse: [] } }),
+						},
 						signal,
 						deps.fetch,
 					);

package/src/messenger/session-pool.ts

@@ -5,13 +5,15 @@ interface WorkerProcess {
 	stdout: ReadableStream<Uint8Array>;
 	stderr: ReadableStream<Uint8Array>;
 	exited: Promise<number>;
-	kill(): void;
+	kill(signal?: number | NodeJS.Signals): void;
 }
 
 interface Pending {
 	resolve(text: string): void;
 	reject(error: Error): void;
 	report?: MessengerActivityReporter;
+	result?: string;
+	written?: boolean;
 }
 
 interface Worker {
@@ -19,20 +21,55 @@ interface Worker {
 	pending?: Pending;
 	lastUsed: number;
 	dead: boolean;
+	exited?: boolean;
+	idleTimer?: ReturnType<typeof setTimeout>;
+	exitTimer?: ReturnType<typeof setTimeout>;
 }
 
-export function createMessengerSessionPool(spawn: typeof Bun.spawn = Bun.spawn, limit = 16) {
+export function createMessengerSessionPool(spawn: typeof Bun.spawn = Bun.spawn, limit = 16, idleTimeoutMs = 5 * 60_000, shutdownTimeoutMs = 5_000) {
 	const workers = new Map<string, Worker>();
+	const allWorkers = new Map<Worker, string>();
+	const exits = new Map<Promise<number>, WorkerProcess>();
+	const retiring = new Map<string, Promise<number>>();
+
 	let closed = false;
+	const closedSignal = new AbortController();
+
 	let tick = 0;
 
 	function retire(key: string, worker: Worker) {
 		if (worker.dead) return;
 		worker.dead = true;
 		if (workers.get(key) === worker) workers.delete(key);
+		allWorkers.delete(worker);
+		if (!worker.exited) {
+			retiring.set(key, worker.child.exited);
+			void worker.child.exited.then(
+				() => { if (retiring.get(key) === worker.child.exited) retiring.delete(key); },
+				() => { if (retiring.get(key) === worker.child.exited) retiring.delete(key); },
+			);
+		}
+		if (worker.idleTimer) clearTimeout(worker.idleTimer);
+		if (worker.exitTimer) clearTimeout(worker.exitTimer);
+		worker.idleTimer = undefined;
 		worker.pending?.reject(new Error("Messenger worker stopped"));
 		worker.pending = undefined;
-		worker.child.kill();
+		if (!worker.exited) {
+			try { worker.child.kill(); } catch { /* Shutdown will attempt forced termination. */ }
+		}
+	}
+
+	function finishTurn(key: string, worker: Worker, pending: Pending) {
+		if (worker.pending !== pending || !pending.written || pending.result === undefined) return;
+		worker.pending = undefined;
+		if (worker.exited) {
+			retire(key, worker);
+		} else {
+			worker.lastUsed = ++tick;
+			worker.idleTimer = setTimeout(() => retire(key, worker), idleTimeoutMs);
+			worker.idleTimer.unref();
+		}
+		pending.resolve(pending.result);
 	}
 
 	async function readLines(stream: ReadableStream<Uint8Array>, handle: (line: string) => void) {
@@ -60,8 +97,11 @@ export function createMessengerSessionPool(spawn: typeof Bun.spawn = Bun.spawn,
 		}
 		const child = spawn(command, { cwd, env, stdin: "pipe", stdout: "pipe", stderr: "pipe" }) as unknown as WorkerProcess;
 		const worker: Worker = { child, lastUsed: ++tick, dead: false };
+		exits.set(child.exited, child);
+		void child.exited.then(() => exits.delete(child.exited), () => exits.delete(child.exited));
 		workers.set(key, worker);
-		void readLines(child.stdout, line => {
+		allWorkers.set(worker, key);
+		const stdoutDone = readLines(child.stdout, line => {
 			const pending = worker.pending;
 			if (!pending) return;
 			if (line === "JEO_MESSENGER_ERROR") { retire(key, worker); return; }
@@ -69,40 +109,86 @@ export function createMessengerSessionPool(spawn: typeof Bun.spawn = Bun.spawn,
 			try {
 				const text: unknown = JSON.parse(line.slice("JEO_MESSENGER_RESULT ".length));
 				if (typeof text !== "string" || !text.trim()) throw new Error("Invalid response");
-				worker.pending = undefined;
-				worker.lastUsed = ++tick;
-				pending.resolve(text);
+				pending.result = text;
+				finishTurn(key, worker, pending);
 			} catch { retire(key, worker); }
 		}).catch(() => retire(key, worker));
 		void readLines(child.stderr, line => {
-			if (line === "JEO_MESSENGER_STEP") worker.pending?.report?.("Working on your request");
+			if (line.startsWith("JEO_MESSENGER_ACTIVITY ")) {
+				const activityText = line.slice("JEO_MESSENGER_ACTIVITY ".length).trim();
+				if (activityText) worker.pending?.report?.(activityText);
+			} else if (line === "JEO_MESSENGER_STEP") {
+				worker.pending?.report?.("Working on your request");
+			}
 		}).catch(() => retire(key, worker));
-		void child.exited.then(() => retire(key, worker), () => retire(key, worker));
+		void child.exited.then(() => {
+			if (worker.dead) return;
+			worker.exited = true;
+			if (workers.get(key) === worker) workers.delete(key);
+			worker.exitTimer = setTimeout(() => retire(key, worker), shutdownTimeoutMs);
+			worker.exitTimer.unref();
+			void stdoutDone.then(() => {
+				if (!worker.pending?.result || worker.pending.written) retire(key, worker);
+			});
+		}, () => retire(key, worker));
 		return worker;
 	}
 
 	async function turn(key: string, command: string[], cwd: string, env: Record<string, string>, text: string, signal: AbortSignal, report?: MessengerActivityReporter): Promise<string> {
 		if (closed || signal.aborted) throw new Error("Messenger request aborted");
+		const previousExit = retiring.get(key);
+		if (previousExit) {
+			await new Promise<void>((resolve, reject) => {
+				const abort = () => { cleanup(); reject(new Error("Messenger request aborted")); };
+				const cleanup = () => { signal.removeEventListener("abort", abort); closedSignal.signal.removeEventListener("abort", abort); };
+				signal.addEventListener("abort", abort, { once: true });
+				closedSignal.signal.addEventListener("abort", abort, { once: true });
+				if (signal.aborted || closed) { abort(); return; }
+				void previousExit.then(() => { cleanup(); resolve(); }, () => { cleanup(); resolve(); });
+			});
+		}
+		if (closed || signal.aborted) throw new Error("Messenger request aborted");
+		if ([...allWorkers].some(([worker, workerKey]) => workerKey === key && worker.pending)) {
+			throw new Error("Messenger conversation is already active");
+		}
 		const worker = workers.get(key) ?? start(key, command, cwd, env);
 		if (worker.pending) throw new Error("Messenger conversation is already active");
+		if (worker.idleTimer) clearTimeout(worker.idleTimer);
+		worker.idleTimer = undefined;
 		return await new Promise<string>((resolve, reject) => {
 			const abort = () => retire(key, worker);
 			const cleanup = () => signal.removeEventListener("abort", abort);
-			worker.pending = { resolve: value => { cleanup(); resolve(value); }, reject: error => { cleanup(); reject(error); }, report };
+			const pending: Pending = { resolve: value => { cleanup(); resolve(value); }, reject: error => { cleanup(); reject(error); }, report };
+			worker.pending = pending;
 			signal.addEventListener("abort", abort, { once: true });
 			if (signal.aborted) { abort(); return; }
 			void (async () => {
 				await worker.child.stdin.write(`${JSON.stringify(text)}\n`);
 				if (!worker.dead) await worker.child.stdin.flush();
+				pending.written = true;
+				finishTurn(key, worker, pending);
 			})().catch(() => retire(key, worker));
 		});
 	}
 
 	async function close() {
 		closed = true;
-		const all = [...workers.entries()];
-		for (const [key, worker] of all) retire(key, worker);
-		await Promise.allSettled(all.map(([, worker]) => worker.child.exited));
+		closedSignal.abort();
+		for (const [worker, key] of allWorkers) retire(key, worker);
+		const waitForExits = async () => {
+			let timer: ReturnType<typeof setTimeout> | undefined;
+			try {
+				return await Promise.race([
+					Promise.allSettled([...exits.keys()]).then(() => true),
+					new Promise<false>(resolve => { timer = setTimeout(() => resolve(false), shutdownTimeoutMs); }),
+				]);
+			} finally { if (timer) clearTimeout(timer); }
+		};
+		if (await waitForExits()) return;
+		for (const child of exits.values()) {
+			try { child.kill("SIGKILL"); } catch { /* The process may have exited concurrently. */ }
+		}
+		if (!(await waitForExits())) throw new Error("Messenger workers did not exit after forced termination");
 	}
 
 	return { turn, close };

package/src/messenger/types.ts

@@ -55,6 +55,8 @@ export interface MessengerConfig {
 	sessionDir: string;
 	toolNames: string[];
 	platforms: Partial<Record<MessengerPlatform, MessengerPlatformConfig>>;
+	/** Whether each message invocation runs in an isolated independent session. Defaults to true. */
+	independentSessions?: boolean;
 }
 
 export interface MessengerTransportDeps {