@oh-my-pi/pi-coding-agent 17.0.3 → 17.0.5

package/src/dap/types.ts

@@ -484,10 +484,9 @@ export interface DapAdapterConfig {
 	launchDefaults?: Record<string, unknown>;
 	attachDefaults?: Record<string, unknown>;
 	/** "stdio" (default): communicate via stdin/stdout pipes.
-	 *  "socket": adapter uses a network socket instead of stdio.
-	 *  On Linux, connects via a unix domain socket.
-	 *  On macOS, the adapter dials into a local TCP listener (--client-addr). */
-	connectMode?: "stdio" | "socket";
+	 *  "socket": adapter-specific socket launch (currently Delve).
+	 *  "tcp": spawn a DAP server with `${port}` substituted in `args`, then connect to it. */
+	connectMode?: "stdio" | "socket" | "tcp";
 	/** When true, the adapter accepts a directory as the launch `program`
 	 *  (e.g. dlv treats it as a Go package path). When false/undefined, the
 	 *  debug tool rejects directory programs upfront. */
@@ -504,7 +503,7 @@ export interface DapResolvedAdapter {
 	rootMarkers: string[];
 	launchDefaults: Record<string, unknown>;
 	attachDefaults: Record<string, unknown>;
-	connectMode: "stdio" | "socket";
+	connectMode: "stdio" | "socket" | "tcp";
 	acceptsDirectoryProgram: boolean;
 }
 
@@ -581,6 +580,8 @@ export interface DapSessionSummary {
 	outputTruncated: boolean;
 	exitCode?: number;
 	needsConfigurationDone: boolean;
+	parentSessionId?: string;
+	childSessionIds?: string[];
 }
 
 export interface DapContinueOutcome {

package/src/discovery/agents.ts

@@ -1,5 +1,5 @@
 /**
- * Agents (standard) Provider
+ * Agent Dirs (.agent/.agents) Provider
  *
  * Loads skills, rules, prompts, commands, context files, and system prompts
  * from .agent/ and .agents/ directories at both user (~/) and project levels.
@@ -24,7 +24,7 @@ import {
 } from "./helpers";
 
 const PROVIDER_ID = "agents";
-const DISPLAY_NAME = "Agents (standard)";
+const DISPLAY_NAME = "Agent Dirs (.agent/.agents)";
 const PRIORITY = 70;
 const AGENT_DIR_CANDIDATES = [".agent", ".agents"] as const;
 

package/src/extensibility/extensions/runner.ts

@@ -534,8 +534,9 @@ export class ExtensionRunner {
 		return undefined;
 	}
 
-	createContext(): ExtensionContext {
-		const getModel = this.#getModel;
+	/** Creates an extension context, optionally scoped to a provider request model. */
+	createContext(model?: Model): ExtensionContext {
+		const getModel = model ? () => model : this.#getModel;
 		return {
 			ui: this.#uiContext,
 			getContextUsage: () => this.#getContextUsageFn(),
@@ -965,8 +966,9 @@ export class ExtensionRunner {
 		return currentMessages;
 	}
 
-	async emitBeforeProviderRequest(payload: unknown): Promise<BeforeProviderRequestEventResult> {
-		const ctx = this.createContext();
+	/** Runs request payload hooks with the model used for that provider request. */
+	async emitBeforeProviderRequest(payload: unknown, model?: Model): Promise<BeforeProviderRequestEventResult> {
+		const ctx = this.createContext(model);
 		let currentPayload = payload;
 
 		for (const ext of this.extensions) {

package/src/extensibility/legacy-pi-coding-agent-shim.ts

@@ -22,8 +22,10 @@ import {
 	getAgentDbPath,
 	getAgentDir,
 	getProjectDir,
+	isCompiledBinary,
 	parseFrontmatter as parseOmpFrontmatter,
 } from "@oh-my-pi/pi-utils";
+import { getPackageDir as getOmpPackageDir } from "../config";
 import type { PromptTemplate } from "../config/prompt-templates";
 import { type SettingPath, Settings } from "../config/settings";
 import { EditTool } from "../edit";
@@ -1334,6 +1336,30 @@ export function readStoredCredential(provider: string): AuthCredential | undefin
 	return storage.get(provider);
 }
 
+// Pi SDK path helpers. `export * from "../index"` above only forwards
+// `getAgentDir`; `getProjectDir` (a `@oh-my-pi/pi-utils` helper) and
+// `getPackageDir` are absent from that barrel, so legacy extensions importing
+// either fail Bun's static export check during validation (issue #5968).
+export { getProjectDir } from "@oh-my-pi/pi-utils";
+
+/**
+ * Coding-agent package install directory, matching pi's string-valued
+ * `getPackageDir()` contract (extensions do `path.join(getPackageDir(), ...)`
+ * to auto-allow bundled docs/resources).
+ *
+ * omp's canonical `getPackageDir()` (`../config`) returns `undefined` inside a
+ * `bun --compile` binary — `import.meta.dir` is `/$bunfs/root` and no owning
+ * `package.json` exists (issue #1423). Returning `undefined` there would crash
+ * every legacy `path.join(getPackageDir(), ...)` at runtime in the shipped
+ * binary, the primary distribution. So fall back to the executable's own
+ * directory in compiled mode, where the binary *is* the install root. The
+ * `PI_PACKAGE_DIR` override and dev/source/npm-dist walk-up still win via the
+ * canonical helper.
+ */
+export function getPackageDir(): string {
+	return getOmpPackageDir() ?? (isCompiledBinary() ? path.dirname(process.execPath) : process.cwd());
+}
+
 export * from "../index";
 export { formatBytes as formatSize } from "../tools/render-utils";
 export { Type } from "./typebox";

package/src/launch/broker.ts

@@ -4,6 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { Process, type PtyRunResult, PtySession } from "@oh-my-pi/pi-natives";
 import { isEexist, isEnoent, logger, postmortem, procmgr, sanitizeText } from "@oh-my-pi/pi-utils";
+import { hostHasInheritableConsole } from "../eval/py/spawn-options";
 import { truncateHead, truncateHeadBytes, truncateTail, truncateTailBytes } from "../session/streaming-output";
 import { workerEnvFromParent } from "../subprocess/worker-client";
 import { daemonBrokerEndpoint } from "./paths";
@@ -24,6 +25,7 @@ import {
 	parseDaemonSpec,
 	parseDaemonWireRequest,
 } from "./protocol";
+import { resolveDaemonSpawnOptions } from "./spawn-options";
 
 const DEFAULT_IDLE_GRACE_MS = 3_000;
 const MAX_REQUEST_BYTES = 1024 * 1024;
@@ -36,6 +38,10 @@ const PID_FILE = "broker.pid";
 const META_FILE = "meta.json";
 const LOG_FILE = "output.log";
 const PREVIOUS_LOG_FILE = "output.previous.log";
+const DAEMON_SPAWN_OPTIONS = resolveDaemonSpawnOptions({
+	platform: process.platform,
+	hostHasInheritableConsole: hostHasInheritableConsole(),
+});
 
 const SIGNAL_NUMBER: Record<DaemonSignal, number> = {
 	SIGINT: os.constants.signals.SIGINT,
@@ -537,6 +543,15 @@ class DaemonBroker {
 			if (error) record.log?.append(`PTY output error: ${error.message}\n`);
 			if (chunk) this.#onOutput(record, generation, chunk);
 		};
+		const started = Promise.withResolvers<number | undefined>();
+		const onStart = (error: Error | null, pid: number): void => {
+			if (error) {
+				record.log?.append(`PTY startup callback failed: ${error.message}\n`);
+				started.resolve(undefined);
+				return;
+			}
+			started.resolve(Number.isSafeInteger(pid) && pid > 0 ? pid : undefined);
+		};
 		let run: Promise<PtyRunResult>;
 		if (process.platform === "win32") {
 			run = session.startArgv(
@@ -546,41 +561,29 @@ class DaemonBroker {
 					...options,
 				},
 				onChunk,
+				onStart,
 			);
 		} else {
-			const pidPath = path.join(record.dir, "process.pid");
-			await fs.rm(pidPath, { force: true });
 			const argv = [record.spec.application, ...record.spec.args];
-			const command = [
-				`printf '%s' "$$" > ${quoteShellArg(pidPath)}`,
-				`exec ${argv.map(quoteShellArg).join(" ")}`,
-			].join("; ");
+			const command = `exec ${argv.map(quoteShellArg).join(" ")}`;
 			const shell = procmgr.getShellConfig().shell;
-			run = session.start({ command, shell, ...options }, onChunk);
+			run = session.start({ command, shell, ...options }, onChunk, onStart);
 		}
-		void run
-			.then(result => this.#onPtyExit(record, generation, result))
-			.catch(error =>
-				this.#settle(record, generation, undefined, error instanceof Error ? error.message : String(error)),
-			);
+		void run.then(
+			async result => {
+				await this.#onPtyExit(record, generation, result);
+				started.resolve(undefined);
+			},
+			async error => {
+				await this.#settle(record, generation, undefined, error instanceof Error ? error.message : String(error));
+				started.resolve(undefined);
+			},
+		);
 
-		if (process.platform === "win32") return;
-		const pidPath = path.join(record.dir, "process.pid");
-		const deadline = Date.now() + 5_000;
-		const pidFile = Bun.file(pidPath);
-		while (Date.now() < deadline && generation === record.generation) {
-			try {
-				const pid = Number.parseInt((await pidFile.text()).trim(), 10);
-				if (Number.isSafeInteger(pid) && pid > 0) {
-					record.snapshot.pid = pid;
-					this.#persist(record);
-					return;
-				}
-			} catch (error) {
-				if (!isEnoent(error)) throw error;
-			}
-			if (terminalState(record.snapshot.state)) return;
-			await Bun.sleep(20);
+		const pid = await started.promise;
+		if (pid !== undefined && generation === record.generation) {
+			record.snapshot.pid = pid;
+			this.#persist(record);
 		}
 	}
 
@@ -591,7 +594,7 @@ class DaemonBroker {
 			stdin: "pipe",
 			stdout: "pipe",
 			stderr: "pipe",
-			detached: true,
+			...DAEMON_SPAWN_OPTIONS,
 		});
 		record.process = process;
 		record.input = process.stdin;
@@ -614,7 +617,7 @@ class DaemonBroker {
 				cwd: record.spec.cwd,
 				env: workerEnvFromParent(record.spec.env),
 				stdio: ["ignore", output.fd, output.fd],
-				detached: true,
+				...DAEMON_SPAWN_OPTIONS,
 			});
 			record.process = process;
 			record.snapshot.pid = process.pid;

package/src/launch/client.ts

@@ -3,6 +3,7 @@ import * as net from "node:net";
 import * as os from "node:os";
 import * as path from "node:path";
 import { isEexist, isEisdir, isEnoent, postmortem } from "@oh-my-pi/pi-utils";
+import { hostHasInheritableConsole } from "../eval/py/spawn-options";
 import { resolveWorkerSpawnCmd, workerEnvFromParent } from "../subprocess/worker-client";
 import { daemonBrokerEndpoint, daemonRuntimeDir } from "./paths";
 import {
@@ -16,10 +17,15 @@ import {
 	parseDaemonRpcResult,
 	parseDaemonWireResponse,
 } from "./protocol";
+import { resolveDaemonSpawnOptions } from "./spawn-options";
 
 const CONNECT_TIMEOUT_MS = 10_000;
 const CONNECT_RETRY_MS = 50;
 const TOKEN_FILE = "broker.token";
+const BROKER_SPAWN_OPTIONS = resolveDaemonSpawnOptions({
+	platform: process.platform,
+	hostHasInheritableConsole: hostHasInheritableConsole(),
+});
 
 interface PendingRequest {
 	operation: DaemonOperation;
@@ -228,7 +234,7 @@ class SocketDaemonClient implements DaemonBrokerClient {
 			stdin: "ignore",
 			stdout: "ignore",
 			stderr: "ignore",
-			detached: true,
+			...BROKER_SPAWN_OPTIONS,
 		});
 		child.unref();
 	}

package/src/launch/spawn-options.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "bun:test";
+import { resolveDaemonSpawnOptions } from "./spawn-options";
+
+describe("resolveDaemonSpawnOptions", () => {
+	it("hides Windows daemons when the host has no console", () => {
+		expect(
+			resolveDaemonSpawnOptions({
+				platform: "win32",
+				hostHasInheritableConsole: false,
+			}),
+		).toEqual({ detached: false, windowsHide: true });
+	});
+
+	it("inherits the Windows host console instead of detaching", () => {
+		expect(
+			resolveDaemonSpawnOptions({
+				platform: "win32",
+				hostHasInheritableConsole: true,
+			}),
+		).toEqual({ detached: false, windowsHide: false });
+	});
+
+	it("keeps POSIX daemons in their own session", () => {
+		expect(
+			resolveDaemonSpawnOptions({
+				platform: "linux",
+				hostHasInheritableConsole: false,
+			}),
+		).toEqual({ detached: true });
+	});
+});

package/src/launch/spawn-options.ts

@@ -0,0 +1,17 @@
+/** Platform-specific options for the launch broker and its non-PTY children. */
+export interface DaemonSpawnOptions {
+	detached: boolean;
+	windowsHide?: boolean;
+}
+
+/** Keep launch processes headless without discarding an inheritable Windows console. */
+export function resolveDaemonSpawnOptions(opts: {
+	platform: NodeJS.Platform;
+	hostHasInheritableConsole: boolean;
+}): DaemonSpawnOptions {
+	if (opts.platform !== "win32") return { detached: true };
+	return {
+		detached: false,
+		windowsHide: !opts.hostHasInheritableConsole,
+	};
+}

package/src/lsp/types.ts

@@ -1,5 +1,6 @@
 import type { ptree } from "@oh-my-pi/pi-utils";
 import { type } from "arktype";
+import { TOOL_TIMEOUTS } from "../tools/tool-timeouts";
 
 // =============================================================================
 // Tool Schema
@@ -14,7 +15,10 @@ export const lspSchema = type({
 	query: "string?",
 	new_name: "string?",
 	apply: "boolean?",
-	timeout: "number?",
+	"timeout?": type.number
+		.atLeast(TOOL_TIMEOUTS.lsp.min)
+		.atMost(TOOL_TIMEOUTS.lsp.max)
+		.describe("Timeout in seconds (default 20; range 5–300)."),
 	payload: "string?",
 });
 

package/src/main.ts

@@ -17,6 +17,7 @@ import {
 	logger,
 	normalizePathForComparison,
 	postmortem,
+	setInteractiveHost,
 	setProjectDir,
 	VERSION,
 } from "@oh-my-pi/pi-utils";
@@ -56,6 +57,7 @@ import { registerDaemonProjectPresence } from "./launch/presence";
 import type { MCPManager } from "./mcp";
 import { InteractiveMode } from "./modes/interactive-mode";
 import type { PrintModeOptions } from "./modes/print-mode";
+import { claimRpcInput } from "./modes/rpc/rpc-input";
 import { CURRENT_SETUP_VERSION } from "./modes/setup-version";
 import { initTheme, stopThemeWatcher } from "./modes/theme/theme";
 import type { SubmittedUserInput } from "./modes/types";
@@ -97,6 +99,7 @@ type RunRpcMode = (
 	session: AgentSession,
 	setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void,
 	eventBus?: EventBus,
+	input?: ReadableStream<Uint8Array>,
 ) => Promise<never>;
 
 export function writeStartupNotice(parsedArgs: Pick<Args, "mode">, text: string): void {
@@ -884,8 +887,12 @@ export async function buildSessionOptions(
 		if (resolved.warning) {
 			process.stderr.write(`${chalk.yellow(`Warning: ${resolved.warning}`)}\n`);
 		}
-		if (resolved.error) {
-			if (!parsed.provider && !parsed.model.includes(":")) {
+		const matchedAfterMissingRolePattern = (resolved.configuredPatternIndex ?? 0) > 0;
+		if (matchedAfterMissingRolePattern) {
+			// Extensions may register an earlier configured role candidate.
+			options.modelPattern = parsed.model;
+		} else if (resolved.error) {
+			if (!parsed.provider && ((resolved.configuredPatterns?.length ?? 0) > 0 || !parsed.model.includes(":"))) {
 				// Model not found in built-in registry — defer resolution to after extensions load
 				// (extensions may register additional providers/models via registerProvider)
 				options.modelPattern = parsed.model;
@@ -1106,6 +1113,9 @@ export async function runRootCommand(
 		process.stderr.write(`${chalk.red("Error: @file arguments are not supported in RPC mode")}\n`);
 		process.exit(1);
 	}
+	const mode = parsedArgs.mode || "text";
+	// RPC owns stdin. Claim its singleton stream before plugin/extension discovery can load an in-process consumer.
+	const rpcInput = mode === "rpc" || mode === "rpc-ui" ? claimRpcInput() : undefined;
 
 	// Kick off plugin-root preload in parallel with the remaining startup work.
 	// Awaited later (before extension/skill discovery in createAgentSession needs it).
@@ -1152,12 +1162,15 @@ export async function runRootCommand(
 	if (parsedArgs.noTitle || parsedArgs.mode === "rpc" || parsedArgs.mode === "rpc-ui" || parsedArgs.mode === "acp") {
 		Bun.env.PI_NO_TITLE = "1";
 	}
-	const mode = parsedArgs.mode || "text";
 	const isProtocolMode = mode === "rpc" || mode === "rpc-ui" || mode === "acp";
 	// Protocol modes own stdin; treating it as prompt text would consume JSON-RPC frames before their transports start.
 	const pipedInput = isProtocolMode ? undefined : await logger.time("readPipedInput", readPipedInput);
 	const autoPrint = pipedInput !== undefined && !parsedArgs.print && parsedArgs.mode === undefined;
 	const isInteractive = !parsedArgs.print && !autoPrint && parsedArgs.mode === undefined;
+	// Only the interactive host renders a focusable Agent Hub / subagent session
+	// tree; declare it so headless subagent optimizations (e.g. skipping replan
+	// title refresh) can tell a focusable process from a print/RPC/eval one.
+	setInteractiveHost(isInteractive);
 
 	// Initialize discovery system with settings for provider persistence
 	logger.time("initializeWithSettings", initializeWithSettings, settingsInstance);
@@ -1509,7 +1522,7 @@ export async function runRootCommand(
 			// Branch-only protocol runner: keep RPC host code out of normal interactive startup.
 			const runRpcMode: RunRpcMode = (await import("./modes/rpc/rpc-mode")).runRpcMode;
 			stopStartupWatchdog();
-			await runRpcMode(session, mode === "rpc-ui" ? setToolUIContext : undefined, eventBus);
+			await runRpcMode(session, mode === "rpc-ui" ? setToolUIContext : undefined, eventBus, rpcInput);
 		} else if (isInteractive) {
 			const versionCheckPromise = checkForNewVersion(VERSION).catch(() => undefined);
 			const changelogMarkdown = await logger.time("main:getChangelogForDisplay", getChangelogForDisplay, parsedArgs);

package/src/mcp/transports/stdio.test.ts

@@ -153,13 +153,21 @@ describe.skipIf(process.platform === "win32")("StdioTransport request write stal
 	}, 8000);
 });
 
+// `kill(pid, 0)` succeeds for a zombie too: a grandchild whose parent (the
+// killed leader) is gone sits as <defunct> until whatever reaps orphans
+// (init/subreaper) gets around to it — which can lag on some hosts. A
+// zombie already received and honored the group SIGKILL; it is just not
+// harvested yet, so treating it as "still alive" would make the group-kill
+// assertions below flaky rather than testing what they claim to test.
 function processExists(pid: number): boolean {
 	try {
 		process.kill(pid, 0);
-		return true;
 	} catch {
 		return false;
 	}
+	const result = Bun.spawnSync(["ps", "-o", "stat=", "-p", String(pid)]);
+	const state = result.stdout.toString().trim();
+	return result.exitCode === 0 && state.length > 0 && !state.startsWith("Z");
 }
 
 // Regression for #5578: `close()` used a bare `this.#process.kill()` (direct

package/src/mnemopi/backend.ts

@@ -145,7 +145,7 @@ export const mnemopiBackend: MemoryBackend = {
 				state = new MnemopiSessionState({ sessionId: session.sessionId, config, session });
 				setMnemopiSessionState(session, state);
 			}
-			await state?.consolidate();
+			await state?.consolidate({ full: true });
 		} catch (error) {
 			logger.warn("Mnemopi: enqueue failed.", { error: String(error) });
 		}

package/src/mnemopi/embed-worker.ts

@@ -9,8 +9,7 @@
  * in either process.
  */
 
-import type { StandardEmbeddingModel } from "@oh-my-pi/pi-mnemopi/core";
-import { loadFastembed } from "@oh-my-pi/pi-mnemopi/core/fastembed-runtime";
+import { defaultLocalModelInitializer, type StandardEmbeddingModel } from "@oh-my-pi/pi-mnemopi/core";
 import type { MnemopiEmbedModelId, MnemopiEmbedTransport, MnemopiEmbedWorkerInbound } from "./embed-protocol";
 
 interface LoadedModel {
@@ -25,12 +24,14 @@ let loaded: Promise<LoadedModel> | null = null;
 let loadedKey = "";
 
 async function loadModel(model: MnemopiEmbedModelId, cacheDir: string | undefined): Promise<LoadedModel> {
-	const { FlagEmbedding } = await loadFastembed();
+	// Route through mnemopi's shared initializer so the worker inherits BOTH
+	// cache heals (sidecar re-fetch AND corrupt-model quarantine/retry) —
+	// fastembed/onnxruntime still load only in this child address space, the
+	// initializer calls loadFastembed() itself.
 	// Cast: `model` arrives as a string from the parent (resolved by
-	// mnemopi's `fastembedModelName`). Cast to the non-CUSTOM overload's
-	// argument so TypeScript picks the standard-model branch — the parent
-	// only ever passes pre-vetted fast-* identifiers.
-	const instance = await FlagEmbedding.init({
+	// mnemopi's `fastembedModelName`); the parent only ever passes pre-vetted
+	// fast-* identifiers.
+	const instance = await defaultLocalModelInitializer({
 		model: model as StandardEmbeddingModel,
 		cacheDir,
 		showDownloadProgress: false,

package/src/mnemopi/state.ts

@@ -454,18 +454,23 @@ export class MnemopiSessionState {
 		this.lastRetainedTurn = userTurns;
 	}
 
-	async forceRetainCurrentSession(): Promise<void> {
+	async forceRetainCurrentSession(options: { extract?: boolean } = {}): Promise<void> {
 		if (this.aliasOf) return;
 		const flat = extractMessages(this.session.sessionManager);
-		await this.retainMessages(flat, this.sessionId);
+		await this.retainMessages(flat, this.sessionId, options);
 		this.lastRetainedTurn = flat.filter(message => message.role === "user").length;
 	}
 
-	async retainMessages(messages: Array<{ role: string; content: string }>, sourceId: string): Promise<void> {
+	async retainMessages(
+		messages: Array<{ role: string; content: string }>,
+		sourceId: string,
+		options: { extract?: boolean } = {},
+	): Promise<void> {
 		const { transcript, messageCount } = prepareRetentionTranscript(messages, true);
 		if (!transcript) return;
 		const { transcript: extractText } = prepareUserRetentionTranscript(messages);
 		const { transcript: embedText } = prepareEmbeddableRetentionTranscript(messages);
+		const shouldExtract = options.extract !== false && extractText !== null;
 		this.rememberInScope(transcript, {
 			source: "coding-agent-transcript",
 			importance: 0.65,
@@ -476,9 +481,9 @@ export class MnemopiSessionState {
 				cwd: this.session.sessionManager.getCwd(),
 			},
 			scope: "bank",
-			extract: extractText !== null,
-			extractEntities: extractText !== null,
-			extractText,
+			extract: shouldExtract,
+			extractEntities: shouldExtract,
+			extractText: shouldExtract ? extractText : null,
 			embedText,
 			veracity: "unknown",
 			memoryType: "episode",
@@ -530,22 +535,42 @@ export class MnemopiSessionState {
 	 * otherwise enqueue would report success while leaving the subagent's
 	 * retained memories unconsolidated until the parent eventually shuts down
 	 * (PR #2327 review).
+	 *
+	 * @param options.full - When true, run `sleepAllSessions` on every owned bank
+	 *  (the full cross-session consolidation used by `/memory enqueue`). When
+	 *  false (the default), run only `sleep` on the current session for a
+	 *  lighter, bounded shutdown pass.
+	 * @param options.sleep - When false, skips the bank sleep step entirely.
+	 *  Used on the interactive shutdown path so `dispose` does not block on
+	 *  synchronous consolidation of old working rows from previous sessions.
+	 * @param options.extract - When false, the retained transcript is stored but
+	 *  no LLM fact extraction is scheduled. Used on the interactive shutdown path
+	 *  so `dispose` does not block on a fresh LLM round-trip.
 	 */
-	async consolidate(): Promise<void> {
-		await this.forceRetainCurrentSession();
+	async consolidate(options: { full?: boolean; extract?: boolean; sleep?: boolean } = {}): Promise<void> {
+		await this.forceRetainCurrentSession({ extract: options.extract });
 		for (const memory of this.scoped.owned) {
 			await memory.flushExtractions();
-			memory.sleepAllSessions(false);
+			if (options.sleep === false) continue;
+			if (options.full) {
+				memory.sleepAllSessions(false);
+			} else {
+				memory.sleep(false);
+			}
 		}
 	}
 
 	/**
-	 * Release the per-session resources. Defaults to running {@link consolidate}
-	 * before closing handles so normal session shutdown promotes working memory
-	 * into long-term storage. Callers that are about to delete the DB files —
-	 * e.g. `mnemopiBackend.clear` — pass `{ consolidate: false }` to skip the
-	 * extraction/sleep pass, since spending tokens on memories that will be
-	 * wiped on the next line is wasted work (PR #2327 review).
+	 * Release the per-session resources. Defaults to running a lighter
+	 * {@link consolidate} pass before closing handles: it retains the current
+	 * transcript and flushes in-flight extractions, but skips the synchronous
+	 * bank sleep so normal session shutdown returns promptly. Full promotion of
+	 * working memory into long-term storage is still performed by the explicit
+	 * `/memory enqueue` and backend enqueue paths. Callers that are about to
+	 * delete the DB files — e.g. `mnemopiBackend.clear` — pass
+	 * `{ consolidate: false }` to skip the retain/flush pass, since spending
+	 * tokens on memories that will be wiped on the next line is wasted work
+	 * (PR #2327 review).
 	 *
 	 * `timeoutMs` caps how long the consolidate await blocks the caller
 	 * (the user-visible `/quit` / `/exit` shutdown path passes this so
@@ -569,9 +594,11 @@ export class MnemopiSessionState {
 			closeOwned();
 			return;
 		}
-		const consolidatePromise = this.consolidate().catch((error: unknown) => {
-			logger.warn("Mnemopi: consolidation on dispose failed.", { error: String(error) });
-		});
+		const consolidatePromise = this.consolidate({ full: false, extract: false, sleep: false }).catch(
+			(error: unknown) => {
+				logger.warn("Mnemopi: consolidation on dispose failed.", { error: String(error) });
+			},
+		);
 		const { timeoutMs } = options;
 		if (timeoutMs !== undefined && timeoutMs > 0) {
 			const TIMED_OUT = Symbol("mnemopi.dispose.timedOut");