jeo-code 0.12.10 → 0.12.12

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

@@ -31,11 +31,8 @@ export interface MessengerAdapter {
 		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>;
+	/** Update the request's progress; undefined finishes it with the supplied outcome. */
+	activity?(message: MessengerMessage, text: string | undefined, signal?: AbortSignal, outcome?: "success" | "failure" | "cancelled"): Promise<void>;
 }
 
 export interface MessengerPlatformConfig {
@@ -55,6 +52,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();