jeo-code 0.12.18 → 0.12.21

package/src/messenger/service.ts

@@ -72,6 +72,44 @@ WantedBy=default.target
 `;
 }
 
+/** Where the user service definition lives on this platform, or undefined where services are unsupported. */
+export function messengerServiceFile(plan: MessengerServicePlan, platform: NodeJS.Platform = process.platform, home: string = os.homedir()): string | undefined {
+	if (platform === "darwin") return path.join(home, "Library", "LaunchAgents", `${plan.label}.plist`);
+	if (platform === "linux") return path.join(home, ".config", "systemd", "user", `${plan.label}.service`);
+	return undefined;
+}
+
+/**
+ * Restart an installed service so it picks up a rewritten launcher. Returns `"not installed"` when no
+ * definition exists; a definition that cannot be restarted is an error, never a silent stale service.
+ */
+export async function restartMessengerService(
+	plan: MessengerServicePlan,
+	platform: NodeJS.Platform = process.platform,
+	home: string = os.homedir(),
+): Promise<"restarted" | "not installed"> {
+	const file = messengerServiceFile(plan, platform, home);
+	if (!file || !(await fs.stat(file).then(stat => stat.isFile(), () => false))) return "not installed";
+	if (platform === "darwin") {
+		const domain = `gui/${process.getuid?.() ?? 0}`;
+		// kickstart -k restarts a loaded job; a definition that is on disk but unloaded is bootstrapped instead.
+		if ((await $`launchctl kickstart -k ${domain}/${plan.label}`.quiet().nothrow()).exitCode !== 0) {
+			if ((await $`launchctl bootstrap ${domain} ${file}`.quiet().nothrow()).exitCode !== 0) throw new Error(`launchctl could not restart ${plan.label}`);
+		}
+		for (let attempt = 0; attempt < 20; attempt++) {
+			const status = await $`launchctl print ${domain}/${plan.label}`.quiet().nothrow();
+			if (status.exitCode === 0 && /\bstate = running\b/.test(status.text())) return "restarted";
+			await Bun.sleep(500);
+		}
+		throw new Error(`launchd job ${plan.label} did not reach the running state; see ${plan.logFile}`);
+	}
+	const unit = `${plan.label}.service`;
+	if ((await $`systemctl --user restart ${unit}`.quiet().nothrow()).exitCode !== 0) throw new Error(`systemctl --user could not restart ${unit}`);
+	const active = await $`systemctl --user is-active ${unit}`.quiet().nothrow();
+	if (active.text().trim() !== "active") throw new Error(`${unit} is not active; see ${plan.logFile}`);
+	return "restarted";
+}
+
 /**
  * Install (or replace) and start the service, then confirm the platform reports it running.
  * Returns a one-line description of where it was installed.
@@ -82,7 +120,7 @@ export async function installMessengerService(
 	home: string = os.homedir(),
 ): Promise<string> {
 	if (platform === "darwin") {
-		const file = path.join(home, "Library", "LaunchAgents", `${plan.label}.plist`);
+		const file = messengerServiceFile(plan, platform, home)!;
 		await Bun.write(file, launchdPlist(plan));
 		const domain = `gui/${process.getuid?.() ?? 0}`;
 		await $`launchctl bootout ${domain} ${file}`.quiet().nothrow();
@@ -103,7 +141,7 @@ export async function installMessengerService(
 	}
 	if (platform === "linux") {
 		const unit = `${plan.label}.service`;
-		const file = path.join(home, ".config", "systemd", "user", unit);
+		const file = messengerServiceFile(plan, platform, home)!;
 		await fs.mkdir(path.dirname(file), { recursive: true });
 		await Bun.write(file, systemdUnit(plan));
 		const reload = await $`systemctl --user daemon-reload`.quiet().nothrow();

package/src/messenger/session-pool.ts

@@ -1,4 +1,5 @@
 import type { MessengerActivityReporter } from "./types";
+import { MessengerUnverifiedReplyError } from "./types";
 
 interface WorkerProcess {
 	stdin: { write(data: string): unknown; flush(): unknown; end(): unknown };
@@ -15,6 +16,8 @@ interface Pending {
 	reject(error: Error): void;
 	report?: MessengerActivityReporter;
 	result?: string;
+	/** The result is an UNVERIFIED-marked answer: the turn rejects with it while the worker keeps serving. */
+	unverified?: boolean;
 	written?: boolean;
 }
 
@@ -32,18 +35,39 @@ interface Worker {
 	cleanupError?: Error;
 	idleTimer?: ReturnType<typeof setTimeout>;
 	exitTimer?: ReturnType<typeof setTimeout>;
+	/** Diagnostic lines already forwarded for this worker. */
+	diagnostics: number;
 }
 
 /** Resident sessions the pool keeps, and the number of turns it runs at once. */
 export const MESSENGER_SESSION_LIMIT = 16;
+/** Operator-visible worker stderr is bounded per worker so a chatty worker cannot flood the gateway log. */
+export const MESSENGER_WORKER_DIAGNOSTIC_LINES = 20;
+const MAX_DIAGNOSTIC_LINE_LENGTH = 300;
 
-export function createMessengerSessionPool(spawn: typeof Bun.spawn = Bun.spawn, limit = MESSENGER_SESSION_LIMIT, idleTimeoutMs = 5 * 60_000, shutdownTimeoutMs = 5_000, options: { requireSandboxCleanup?: boolean } = {}) {
+export interface MessengerSessionPoolOptions {
+	requireSandboxCleanup?: boolean;
+	/**
+	 * Receives bounded, non-protocol worker stderr lines and abnormal exits for the operator log. Worker
+	 * environments carry no platform tokens, and the conversation key is a route digest, never message text.
+	 */
+	onDiagnostic?: (key: string, line: string) => void;
+}
+
+/** One printable, bounded line: control characters collapse to spaces. */
+function diagnosticLine(text: string): string {
+	const line = text.replace(/[\u0000-\u001f\u007f-\u009f]+/g, " ").trim();
+	return line.length > MAX_DIAGNOSTIC_LINE_LENGTH ? `${line.slice(0, MAX_DIAGNOSTIC_LINE_LENGTH - 1)}…` : line;
+}
+
+export function createMessengerSessionPool(spawn: typeof Bun.spawn = Bun.spawn, limit = MESSENGER_SESSION_LIMIT, idleTimeoutMs = 5 * 60_000, shutdownTimeoutMs = 5_000, options: MessengerSessionPoolOptions = {}) {
 	const workers = new Map<string, Worker>();
 	const allWorkers = new Map<Worker, string>();
 	const exits = new Map<Promise<number>, Worker>();
 	const retiring = new Map<string, Promise<number>>();
 	const keyTails = new Map<string, Promise<void>>();
 	const requireSandboxCleanup = options.requireSandboxCleanup === true;
+	const onDiagnostic = options.onDiagnostic;
 	const incomplete = (detail: string) => new Error(`REVOKE_INCOMPLETE: ${detail}`);
 
 	let closed = false;
@@ -138,7 +162,8 @@ export function createMessengerSessionPool(spawn: typeof Bun.spawn = Bun.spawn,
 			worker.idleTimer = setTimeout(() => retire(key, worker), idleTimeoutMs);
 			worker.idleTimer.unref();
 		}
-		pending.resolve(pending.result);
+		if (pending.unverified) pending.reject(new MessengerUnverifiedReplyError(pending.result));
+		else pending.resolve(pending.result);
 	}
 
 	async function readLines(stream: ReadableStream<Uint8Array>, handle: (line: string) => void) {
@@ -191,7 +216,17 @@ export function createMessengerSessionPool(spawn: typeof Bun.spawn = Bun.spawn,
 		const spawnOptions = { cwd, env: workerEnv, stdin: "pipe", stdout: "pipe", stderr: "pipe", ...(cleanupNonce ? { ipc() {}, serialization: "json" } : {}) };
 		const child = spawn(command, spawnOptions as never) as unknown as WorkerProcess;
 		const cleanup = Promise.withResolvers<number>();
-		const worker: Worker = { child, exit: cleanupNonce ? cleanup.promise : child.exited, cleanupNonce, policyKey, lastUsed: ++tick, dead: false };
+		const worker: Worker = { child, exit: cleanupNonce ? cleanup.promise : child.exited, cleanupNonce, policyKey, lastUsed: ++tick, dead: false, diagnostics: 0 };
+		const diagnose = (text: string): void => {
+			if (!onDiagnostic || worker.diagnostics > MESSENGER_WORKER_DIAGNOSTIC_LINES) return;
+			const line = diagnosticLine(text);
+			if (!line) return;
+			worker.diagnostics++;
+			try { onDiagnostic(key, worker.diagnostics > MESSENGER_WORKER_DIAGNOSTIC_LINES ? "further worker output suppressed" : line); }
+			catch { /* The operator log never affects the turn. */ }
+		};
+		// An exit during a turn, or a non-zero exit, explains the user-visible failure; a clean idle exit is routine.
+		void child.exited.then(code => { if (code !== 0 || worker.pending) diagnose(`worker exited with code ${code}${worker.pending ? " during a turn" : ""}`); }, () => {});
 		exits.set(worker.exit, worker);
 		void worker.exit.then(() => {
 			exits.delete(worker.exit);
@@ -203,6 +238,17 @@ export function createMessengerSessionPool(spawn: typeof Bun.spawn = Bun.spawn,
 			const pending = worker.pending;
 			if (!pending) return;
 			if (line === "JEO_MESSENGER_ERROR") { retire(key, worker); return; }
+			// An exhausted completion gate is a controlled turn end: deliver the marked answer, keep the worker.
+			if (line.startsWith("JEO_MESSENGER_UNVERIFIED ")) {
+				try {
+					const text: unknown = JSON.parse(line.slice("JEO_MESSENGER_UNVERIFIED ".length));
+					if (typeof text !== "string" || !text.trim()) throw new Error("Invalid response");
+					pending.result = text;
+					pending.unverified = true;
+					finishTurn(key, worker, pending);
+				} catch { retire(key, worker); }
+				return;
+			}
 			if (!line.startsWith("JEO_MESSENGER_RESULT ")) return;
 			try {
 				const text: unknown = JSON.parse(line.slice("JEO_MESSENGER_RESULT ".length));
@@ -227,7 +273,7 @@ export function createMessengerSessionPool(spawn: typeof Bun.spawn = Bun.spawn,
 				if (activityText) worker.pending?.report?.(activityText);
 			} else if (line === "JEO_MESSENGER_STEP") {
 				worker.pending?.report?.("Working on your request");
-			}
+			} else diagnose(line);
 		}).catch(() => retire(key, worker));
 		if (cleanupNonce) {
 			void Promise.all([child.exited, stderrDone, stdoutDone]).then(([code]) => {

package/src/messenger/types.ts

@@ -78,6 +78,14 @@ export class MessengerFatalError extends Error {
 	}
 }
 
+/** The agent turn ended without verified completion; `reply` is the UNVERIFIED-marked answer for the user. */
+export class MessengerUnverifiedReplyError extends Error {
+	constructor(readonly reply: string) {
+		super("Messenger agent turn ended without verified completion");
+		this.name = "MessengerUnverifiedReplyError";
+	}
+}
+
 export function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/src/util/slack.ts

@@ -0,0 +1,40 @@
+/**
+ * Slack-style direct-request detection (ops/specs/slack-autopilot.md).
+ *
+ * Goal: free-form natural-language input ("fix the build error") routes to
+ * the interactive agent, while command invocations (`joc status`), flags,
+ * and single-token typos still reach the normal dispatcher so command
+ * resolution and "did you mean" suggestions keep working.
+ *
+ * Pure, domain-agnostic helpers only (src/util convention).
+ */
+
+/** Command-shaped token: `status`, `evolve-core`, `skills:list`, … */
+const COMMAND_SHAPED = /^[a-z][a-z0-9:_-]*$/i;
+
+/**
+ * Slack command-prefix check: `/deploy` and `!ops` style messages are
+ * explicit commands, never direct requests.
+ */
+export function isSlackDM(text: string): boolean {
+  return !text.startsWith("/") && !text.startsWith("!");
+}
+
+/**
+ * True when the argv tokens look like a free-form request rather than a
+ * CLI command invocation.
+ *
+ * - empty / flags-only input → false (dispatcher owns defaults)
+ * - `/cmd` or `!cmd` prefix → false (explicit command style)
+ * - single command-shaped token → false (could be a typo of a real
+ *   command; the dispatcher must keep its suggestion path)
+ * - anything else (multi-word sentences, CJK text, punctuation) → true
+ */
+export function isDirectRequest(tokens: readonly string[]): boolean {
+  const words = tokens.filter(t => !t.startsWith("-"));
+  if (words.length === 0) return false;
+  const first = words[0];
+  if (!isSlackDM(first)) return false;
+  if (words.length === 1 && COMMAND_SHAPED.test(first)) return false;
+  return true;
+}