jeo-code 0.12.9 → 0.12.11

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

@@ -12,6 +12,7 @@ const TOOLS: Record<string, true> = {
 	bash: true,
 	edit: true,
 	write: true,
+	computer: true,
 };
 
 function object(value: unknown, label: string): Record<string, unknown> {
@@ -60,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");
@@ -97,14 +100,15 @@ 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)) ||
 		new Set(toolNames).size !== toolNames.length
 	) {
-		throw new Error("toolNames must be a unique list drawn from read, grep, glob, bash, edit, write");
+		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(
@@ -113,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 {

package/src/skills/catalog.ts

@@ -117,9 +117,9 @@ export function buildSkillTask(skill: SkillDoc, intent: string, invokedAs?: stri
         : "Carry out this skill's workflow now. If it needs a concrete target you weren't given, make a reasonable assumption or ask the user via done."),
   ].join("\n");
 }
-export function skillsPromptSection(skills: SkillDoc[] = SKILLS): string {
+export function skillsPromptSection(skills: SkillDoc[] = SKILLS, currentTask?: string): string {
   const bundleSkills: SkillDoc[] = [];
-  const configuredSkills: SkillDoc[] = [];
+  let configuredSkills: SkillDoc[] = [];
 
   const bundleNames = new Set(BUILTIN_SKILL_NAMES);
   for (const s of skills) {
@@ -130,6 +130,20 @@ export function skillsPromptSection(skills: SkillDoc[] = SKILLS): string {
     }
   }
 
+  // When a task is provided and skills exceed budget, sort configured skills by relevance
+  if (currentTask && currentTask.trim().length > 0 && configuredSkills.length > 5) {
+    const qTokens = new Set(
+      currentTask.toLowerCase().match(/[a-z0-9._-]{3,}/g) ?? []
+    );
+    configuredSkills = [...configuredSkills].sort((a, b) => {
+      const aScore = (a.name.toLowerCase().split(/[._-]/).some(t => qTokens.has(t)) ? 10 : 0) +
+        (qTokens.has(a.name.toLowerCase()) ? 20 : 0);
+      const bScore = (b.name.toLowerCase().split(/[._-]/).some(t => qTokens.has(t)) ? 10 : 0) +
+        (qTokens.has(b.name.toLowerCase()) ? 20 : 0);
+      return bScore - aScore;
+    });
+  }
+
   const lines: string[] = [];
   let used = 0;
 
@@ -295,15 +309,18 @@ export function skillDirs(cwd: string = process.cwd()): string[] {
     path.join(userHome, ".claude", "skills"),
     path.join(home, "agent", "skills"),
     path.join(userHome, ".agents", "skills"),
+    path.join(userHome, ".agent-skills"),
     userSkillsDir(),
     path.join(cwd, ".claude", "skills"),
     path.join(cwd, ".agents", "skills"),
+    path.join(cwd, ".agent-skills"),
     path.join(cwd, ".jeo", "skills"),
     path.join(cwd, ".jeo", "agent", "skills"),
     ...configured,
   ];
 }
 
+
 /** A frontmatter `name:` usable as a skill identity: one bare token, no spaces. */
 function sanitizeSkillName(raw: string | undefined): string | undefined {
   const m = (raw ?? "").trim();