@oh-my-pi/pi-coding-agent 15.7.1 → 15.7.3

package/src/eval/js/shared/local-module-loader.ts

@@ -9,6 +9,8 @@ interface LocalModuleEntry {
 	version: number;
 	identifier: string;
 	module: vm.SourceTextModule;
+	/** Memoized link+evaluate of this module as a graph root; set lazily by `#loadLocalModule`. */
+	loaded?: Promise<void>;
 }
 
 export type LocalImportResolution = { mode: "local"; value: unknown } | { mode: "external"; target: string };
@@ -26,6 +28,7 @@ export class LocalModuleLoader {
 	#moduleBuilds = new Map<string, Promise<LocalModuleEntry>>();
 	#externalModules = new Map<string, Promise<vm.Module>>();
 	#requireCache = new Map<string, NodeJS.Require>();
+	#modulePaths = new WeakMap<vm.Module, string>();
 
 	constructor(sessionId: string) {
 		this.#context = vm.createContext(globalThis);
@@ -68,8 +71,8 @@ export class LocalModuleLoader {
 	async #resolveFromBase(baseDir: string, source: string): Promise<LocalImportResolution> {
 		const resolved = resolveImportSpecifier(baseDir, source);
 		if (isLocalPathSpecifier(source) && isManagedLocalModulePath(resolved)) {
-			const entry = await this.#ensureLocalModule(resolved);
-			return { mode: "local", value: entry.module.namespace };
+			const module = await this.#loadLocalModule(resolved);
+			return { mode: "local", value: module.namespace };
 		}
 		return { mode: "external", target: normalizeImportTarget(resolved) };
 	}
@@ -86,6 +89,11 @@ export class LocalModuleLoader {
 		return await buildPromise;
 	}
 
+	// Construct (parse + register) a local module WITHOUT linking or evaluating it.
+	// Linking and evaluation are driven once from the graph root in `#linkAndEvaluate`;
+	// doing them per-module inside the recursive linker re-enters Bun's node:vm linker
+	// mid-instantiation, which segfaults JSC (getImportedModule on a null record) whenever
+	// the local graph contains an import cycle.
 	async #buildLocalModule(modulePath: string): Promise<LocalModuleEntry> {
 		const rawSource = fs.readFileSync(modulePath, "utf8");
 		const stripped = stripTypeScriptSyntax(rawSource, {
@@ -116,28 +124,85 @@ export class LocalModuleLoader {
 				(meta as { url?: string; path?: string; dir?: string }).dir = moduleDir;
 			},
 			importModuleDynamically: async specifier => {
-				return await this.#resolveLinkedModule(modulePath, String(specifier));
+				return await this.#resolveDynamicImport(modulePath, String(specifier));
 			},
 		});
+		this.#modulePaths.set(module, modulePath);
 		const entry: LocalModuleEntry = { version, identifier, module };
 		this.#moduleEntries.set(modulePath, entry);
+		return entry;
+	}
+
+	// Construct (if needed) then link+evaluate a local module as a graph root, returning
+	// the evaluated module. Link and evaluate run exactly once over the whole reachable
+	// graph; the static linker only constructs dependencies, letting node:vm instantiate
+	// cyclic graphs in a single pass.
+	async #loadLocalModule(modulePath: string): Promise<vm.SourceTextModule> {
+		const entry = await this.#ensureLocalModule(modulePath);
+		entry.loaded ??= this.#linkAndEvaluate(entry, modulePath);
+		await entry.loaded;
+		return entry.module;
+	}
+
+	async #linkAndEvaluate(entry: LocalModuleEntry, modulePath: string): Promise<void> {
+		const { module } = entry;
 		try {
-			await module.link(async specifier => await this.#resolveLinkedModule(modulePath, specifier));
-			await module.evaluate();
-			return entry;
+			if (module.status === "unlinked") await module.link(this.#linkResolve);
+			if (module.status === "linked") await module.evaluate();
 		} catch (error) {
-			this.#moduleEntries.delete(modulePath);
+			this.#invalidateFailedLoad(modulePath);
 			throw error;
 		}
+		if (module.status === "errored") {
+			this.#invalidateFailedLoad(modulePath);
+			throw module.error;
+		}
 	}
 
-	async #resolveLinkedModule(referrerPath: string, specifier: string): Promise<vm.Module> {
-		const baseDir = path.dirname(referrerPath);
-		const resolved = resolveImportSpecifier(baseDir, specifier);
+	// Shared static-link resolver for `module.link()`. node:vm passes the referencing
+	// module and reuses this one resolver for the entire graph, so the referrer path is
+	// recovered from `#modulePaths`. Local dependencies are constructed but NOT linked or
+	// evaluated here (the root drives that); externals are loaded eagerly — they carry no
+	// imports and cannot participate in a cycle.
+	#linkResolve = async (specifier: string, referencingModule: vm.Module): Promise<vm.Module> => {
+		const referrerPath = this.#modulePaths.get(referencingModule);
+		if (referrerPath === undefined) {
+			throw new Error(`local module loader: unknown referrer while linking "${specifier}"`);
+		}
+		const resolved = resolveImportSpecifier(path.dirname(referrerPath), specifier);
 		if (isLocalPathSpecifier(specifier) && isManagedLocalModulePath(resolved)) {
 			return (await this.#ensureLocalModule(resolved)).module;
 		}
 		return await this.#ensureExternalModule(normalizeImportTarget(resolved));
+	};
+
+	// Resolver for runtime `import()` inside evaluated module code: the result must be a
+	// fully linked+evaluated module, so local targets are loaded as graph roots.
+	async #resolveDynamicImport(referrerPath: string, specifier: string): Promise<vm.Module> {
+		const resolved = resolveImportSpecifier(path.dirname(referrerPath), specifier);
+		if (isLocalPathSpecifier(specifier) && isManagedLocalModulePath(resolved)) {
+			return await this.#loadLocalModule(resolved);
+		}
+		return await this.#ensureExternalModule(normalizeImportTarget(resolved));
+	}
+
+	// A failed link/evaluate can leave a partial graph cached. Drop every reachable module
+	// that is not fully evaluated so the next attempt reconstructs it; fully evaluated
+	// modules keep valid namespaces and stay cached.
+	#invalidateFailedLoad(rootPath: string): void {
+		const stack = [rootPath];
+		const seen = new Set<string>();
+		while (stack.length > 0) {
+			const current = stack.pop();
+			if (current === undefined || seen.has(current)) continue;
+			seen.add(current);
+			const entry = this.#moduleEntries.get(current);
+			if (entry && entry.module.status === "evaluated") continue;
+			this.#moduleEntries.delete(current);
+			this.#moduleBuilds.delete(current);
+			const deps = this.#moduleDeps.get(current);
+			if (deps) for (const dep of deps) stack.push(dep);
+		}
 	}
 
 	async #ensureExternalModule(target: string): Promise<vm.Module> {

package/src/eval/js/shared/prelude.txt

@@ -39,11 +39,88 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 		return values.length === 1 ? values[0] : values;
 	};
 
+	const hasOwn = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
+
 	const llm = async (prompt, opts = {}) => {
 		const o = toOptions(opts);
 		const res = await globalThis.__omp_call_tool__("__llm__", { prompt, ...o });
 		const text = res && typeof res === "object" ? res.text : res;
-		return o.schema ? JSON.parse(text) : text;
+		return hasOwn(o, "schema") ? JSON.parse(text) : text;
+	};
+
+	const agent = async (prompt, opts = {}) => {
+		const o = toOptions(opts);
+		const res = await globalThis.__omp_call_tool__("__agent__", { prompt, ...o });
+		const text = res && typeof res === "object" ? res.text : res;
+		return hasOwn(o, "schema") ? JSON.parse(text) : text;
+	};
+
+	const normalizeConcurrency = value => {
+		const number = Number(value ?? 4);
+		if (!Number.isFinite(number)) return 4;
+		return Math.max(1, Math.min(16, Math.trunc(number)));
+	};
+
+	const __pool = async (items, limit, fn) => {
+		const list = Array.from(items ?? []);
+		const concurrency = Math.min(normalizeConcurrency(limit), list.length);
+		const results = new Array(list.length);
+		let next = 0;
+		const worker = async () => {
+			while (true) {
+				const index = next++;
+				if (index >= list.length) return;
+				results[index] = await fn(list[index], index);
+			}
+		};
+		await Promise.all(Array.from({ length: concurrency }, () => worker()));
+		return results;
+	};
+
+	const parallel = async (thunks, opts = {}) =>
+		__pool(thunks, toOptions(opts).concurrency, (thunk, index) => {
+			if (typeof thunk !== "function") throw new TypeError("parallel() expects an iterable of functions");
+			return thunk(index);
+		});
+
+	const pipeline = async (items, ...stagesAndOptions) => {
+		let opts = {};
+		const last = stagesAndOptions.at(-1);
+		if (last && typeof last === "object" && !Array.isArray(last)) {
+			opts = last;
+			stagesAndOptions = stagesAndOptions.slice(0, -1);
+		}
+		let current = Array.from(items ?? []);
+		for (const stage of stagesAndOptions) {
+			if (typeof stage !== "function") throw new TypeError("pipeline() stages must be functions");
+			current = await __pool(current, toOptions(opts).concurrency, stage);
+		}
+		return current;
+	};
+
+	const log = message => globalThis.__omp_emit_status__("log", { message: String(message) });
+
+	const phase = title => {
+		globalThis.__omp_phase__ = String(title);
+		globalThis.__omp_emit_status__("phase", { title: String(title) });
+	};
+
+	const __budgetSnap = async () => {
+		const r = await globalThis.__omp_call_tool__("__budget__", {});
+		return r && typeof r === "object" ? r : {};
+	};
+
+	const budget = {
+		total: async () => {
+			const s = await __budgetSnap();
+			return s.total ?? null;
+		},
+		spent: async () => Number((await __budgetSnap()).spent ?? 0),
+		remaining: async () => {
+			const s = await __budgetSnap();
+			return s.total == null ? Infinity : Math.max(0, Number(s.total) - Number(s.spent ?? 0));
+		},
+		hard: async () => Boolean((await __budgetSnap()).hard),
 	};
 
 	const display = value => {
@@ -70,6 +147,13 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 	globalThis.tool = tool;
 	globalThis.llm = llm;
 	globalThis.output = output;
+	globalThis.agent = agent;
+	globalThis.parallel = parallel;
+	globalThis.pipeline = pipeline;
+	globalThis.log = log;
+	globalThis.phase = phase;
+	globalThis.budget = budget;
+	globalThis.__pool = __pool;
 	globalThis.read = read;
 	globalThis.write = write;
 	globalThis.append = append;

package/src/eval/js/tool-bridge.ts

@@ -1,6 +1,8 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import type { ToolSession } from "../../tools";
 import { ToolError } from "../../tools/tool-errors";
+import { EVAL_AGENT_BRIDGE_NAME, runEvalAgent } from "../agent-bridge";
+import { EVAL_BUDGET_BRIDGE_NAME, type EvalBudgetResult, runEvalBudget } from "../budget-bridge";
 import { EVAL_LLM_BRIDGE_NAME, runEvalLlm } from "../llm-bridge";
 import type { JsStatusEvent } from "./shared/types";
 
@@ -14,6 +16,7 @@ interface ToolBridgeOptions {
 
 type ToolValue =
 	| string
+	| EvalBudgetResult
 	| {
 			text: string;
 			details?: unknown;
@@ -105,6 +108,12 @@ export async function callSessionTool(name: string, args: unknown, options: Tool
 	if (name === EVAL_LLM_BRIDGE_NAME) {
 		return await runEvalLlm(args, options);
 	}
+	if (name === EVAL_AGENT_BRIDGE_NAME) {
+		return await runEvalAgent(args, options);
+	}
+	if (name === EVAL_BUDGET_BRIDGE_NAME) {
+		return await runEvalBudget(args, options);
+	}
 	const tool = getTool(options.session, name);
 	const normalizedArgs = normalizeArgs(args);
 	const toolCallId = `js-${name}-${crypto.randomUUID()}`;

package/src/eval/py/executor.ts

@@ -25,6 +25,12 @@ export interface PythonExecutorOptions {
 	timeoutMs?: number;
 	/** Absolute wall-clock deadline in milliseconds since epoch */
 	deadlineMs?: number;
+	/**
+	 * Inactivity budget (ms). Used only for timeout-annotation text when the
+	 * caller drives cancellation via an idle-aware `signal` instead of a
+	 * wall-clock `deadlineMs`/`timeoutMs`. Does not arm a timer.
+	 */
+	idleTimeoutMs?: number;
 	/** Callback for streaming output chunks (already sanitized) */
 	onChunk?: (chunk: string) => Promise<void> | void;
 	/** AbortSignal for cancellation */
@@ -57,6 +63,13 @@ export interface PythonExecutorOptions {
 	toolSession?: ToolSession;
 	/** Callback for status events emitted by tool bridge invocations. */
 	emitStatus?: (event: JsStatusEvent) => void;
+	/**
+	 * Live status events streamed as they are emitted (both host-side bridge
+	 * helpers like `agent()` and kernel-side `display`/`log`/`phase`). Mirrors
+	 * what lands in `displayOutputs` so callers can render progress before the
+	 * cell finishes.
+	 */
+	onStatus?: (event: JsStatusEvent) => void;
 	/** @internal Bridge session id, set by `executePython` before delegating. */
 	bridgeSessionId?: string;
 	/** @internal Bridge endpoint info, set by `executePython` before delegating. */
@@ -218,18 +231,20 @@ async function waitForPromiseWithCancellation<T>(
 // Result formatting
 // ---------------------------------------------------------------------------
 
-function formatTimeoutAnnotation(timeoutMs?: number): string | undefined {
+function formatTimeoutAnnotation(timeoutMs?: number, idle = false): string | undefined {
+	const suffix = idle ? " of inactivity" : "";
 	if (timeoutMs === undefined) return "Command timed out";
 	const secs = Math.max(1, Math.round(timeoutMs / 1000));
-	return `Command timed out after ${secs} seconds`;
+	return `Command timed out after ${secs} seconds${suffix}`;
 }
 
-function formatKernelTimeoutAnnotation(timeoutMs: number | undefined, kernelKilled: boolean): string {
+function formatKernelTimeoutAnnotation(timeoutMs: number | undefined, kernelKilled: boolean, idle = false): string {
 	const secs = timeoutMs === undefined ? undefined : Math.max(1, Math.round(timeoutMs / 1000));
+	const suffix = idle ? " of inactivity" : "";
 	if (kernelKilled) {
-		return "eval cell timed out and the kernel was unresponsive to interrupt; the kernel has been killed and will be recreated on the next call.";
+		return `eval cell timed out${suffix} and the kernel was unresponsive to interrupt; the kernel has been killed and will be recreated on the next call.`;
 	}
-	const duration = secs === undefined ? "the configured timeout" : `${secs}s`;
+	const duration = secs === undefined ? "the configured timeout" : `${secs}s${suffix}`;
 	return `eval cell timed out after ${duration}; kernel interrupted but remains running. Reset the kernel via { reset: true } if state appears corrupted.`;
 }
 
@@ -473,12 +488,18 @@ async function executeWithKernel(
 	const displayOutputs: KernelDisplayOutput[] = [];
 	const deadlineMs = getExecutionDeadlineMs(options);
 	let executionTimeoutMs: number | undefined;
-
-	const emitStatus =
-		options?.emitStatus ??
-		((event: JsStatusEvent) => {
-			displayOutputs.push({ type: "status", event });
-		});
+	// Idle mode: the caller (eval tool) drives cancellation via an idle-aware
+	// signal and passes no wall-clock deadline, so annotate timeouts with the
+	// configured inactivity budget rather than a remaining-deadline figure.
+	const idleMode = deadlineMs === undefined && options?.idleTimeoutMs !== undefined;
+
+	// Collect every display output and, for status events, stream them live so
+	// long-running bridge helpers (e.g. `agent()`) surface progress mid-cell.
+	const collectDisplay = (output: KernelDisplayOutput) => {
+		displayOutputs.push(output);
+		if (output.type === "status") options?.onStatus?.(output.event);
+	};
+	const emitStatus = options?.emitStatus ?? ((event: JsStatusEvent) => collectDisplay({ type: "status", event }));
 	const runId = `py-${crypto.randomUUID()}`;
 	const unregisterBridge =
 		options?.toolSession && options?.bridgeSessionId
@@ -498,12 +519,16 @@ async function executeWithKernel(
 			signal: options?.signal,
 			timeoutMs: executionTimeoutMs,
 			onChunk: text => sink.push(text),
-			onDisplay: output => void displayOutputs.push(output),
+			onDisplay: output => collectDisplay(output),
 		});
 
 		if (result.cancelled) {
 			const annotation = result.timedOut
-				? formatKernelTimeoutAnnotation(executionTimeoutMs, result.kernelKilled ?? false)
+				? formatKernelTimeoutAnnotation(
+						executionTimeoutMs ?? options?.idleTimeoutMs,
+						result.kernelKilled ?? false,
+						idleMode,
+					)
 				: undefined;
 			return {
 				exitCode: undefined,
@@ -540,7 +565,9 @@ async function executeWithKernel(
 				cancelled: true,
 				displayOutputs,
 				stdinRequested: false,
-				...(await sink.dump(timedOut ? formatTimeoutAnnotation(executionTimeoutMs) : undefined)),
+				...(await sink.dump(
+					timedOut ? formatTimeoutAnnotation(executionTimeoutMs ?? options?.idleTimeoutMs, idleMode) : undefined,
+				)),
 			};
 		}
 		const error = err instanceof Error ? err : new Error(String(err));

package/src/eval/py/index.ts

@@ -28,7 +28,7 @@ export default {
 		const kernelMode = readSetting<PythonExecutorOptions["kernelMode"]>(opts.session, "python.kernelMode");
 		const executorOptions: PythonExecutorOptions = {
 			cwd: opts.cwd,
-			deadlineMs: opts.deadlineMs,
+			idleTimeoutMs: opts.idleTimeoutMs,
 			signal: opts.signal,
 			sessionId: namespaceSessionId(opts.sessionId),
 			kernelMode,
@@ -39,6 +39,7 @@ export default {
 			artifactPath: opts.artifactPath,
 			artifactId: opts.artifactId,
 			onChunk: opts.onChunk,
+			onStatus: opts.onStatus,
 			toolSession: opts.session,
 		};
 		const result = await executePython(code, executorOptions);

package/src/eval/py/prelude.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 if "__omp_prelude_loaded__" not in globals():
     __omp_prelude_loaded__ = True
     from pathlib import Path
-    import os, json
+    import os, json, math
 
     # __omp_display is injected by runner.py before the prelude executes; it
     # mirrors IPython's display() semantics with the same MIME bundle output.
@@ -479,3 +479,134 @@ if "__omp_prelude_loaded__" not in globals():
         res = _bridge_call("__llm__", args)
         text = res.get("text") if isinstance(res, dict) else res
         return json.loads(text) if schema is not None else text
+
+    def agent(prompt, *, agent_type="task", model=None, context=None, label=None, schema=None):
+        """Run a subagent and return its final output.
+
+        `agent_type` selects the subagent definition (default "task"). Pass
+        `model` to override that agent's model, `context` for shared background,
+        `label` for the output artifact id, and `schema` to request structured
+        JSON output; when `schema` is supplied the parsed object is returned.
+        """
+        args = {"prompt": prompt}
+        if agent_type is not None:
+            args["agentType"] = agent_type
+        if model is not None:
+            args["model"] = model
+        if context is not None:
+            args["context"] = context
+        if label is not None:
+            args["label"] = label
+        if schema is not None:
+            args["schema"] = schema
+        res = _bridge_call("__agent__", args)
+        text = res.get("text") if isinstance(res, dict) else res
+        return json.loads(text) if schema is not None else text
+
+    def _normalize_concurrency(value):
+        """Clamp a concurrency hint to [1, 16], defaulting to 4 on bad input."""
+        try:
+            n = int(value)
+        except (TypeError, ValueError):
+            n = 4
+        return max(1, min(16, n))
+
+    def _pool_map(items, fn, concurrency):
+        """Run ``fn`` over ``items`` through a bounded thread pool.
+
+        Preserves input order, barriers until every task settles, and raises the
+        lowest-index exception if any task failed. Each task runs inside a copy
+        of the submitting thread's context so the ``_CURRENT_RID`` ContextVar
+        propagates and bridge calls (agent(), tool.*, etc.) keep working.
+        """
+        import concurrent.futures, contextvars
+        items = list(items)
+        if not items:
+            return []
+        workers = min(_normalize_concurrency(concurrency), len(items))
+        results = [None] * len(items)
+        errors = {}
+        with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as pool:
+            futures = {}
+            for i, item in enumerate(items):
+                ctx = contextvars.copy_context()
+                futures[pool.submit(ctx.run, fn, item)] = i
+            for fut in concurrent.futures.as_completed(futures):
+                i = futures[fut]
+                try:
+                    results[i] = fut.result()
+                except BaseException as exc:  # noqa: BLE001 - propagate to caller
+                    errors[i] = exc
+        if errors:
+            raise errors[min(errors)]
+        return results
+
+    def parallel(thunks, *, concurrency=4):
+        """Run zero-arg callables through a bounded pool, preserving input order.
+
+        Barriers until all finish; re-raises the lowest-index exception if any
+        thunk raised.
+        """
+        thunks = list(thunks)
+        for t in thunks:
+            if not callable(t):
+                raise TypeError("parallel() expects an iterable of zero-arg callables")
+        return _pool_map(thunks, lambda t: t(), concurrency)
+
+    def pipeline(items, *stages, concurrency=4):
+        """Map items left-to-right through one-arg stage callables.
+
+        Every item clears stage N before any item enters stage N+1 (barrier per
+        stage). Stage 1 receives the original item; later stages receive the
+        previous stage's result.
+        """
+        current = list(items)
+        for stage in stages:
+            if not callable(stage):
+                raise TypeError("pipeline() stages must be callables")
+            current = _pool_map(current, stage, concurrency)
+        return current
+
+    def log(message):
+        """Emit a status ``log`` event for TUI rendering."""
+        _emit_status("log", message=str(message))
+        return None
+
+    def phase(title):
+        """Record the current readable phase and emit a status ``phase`` event."""
+        globals()["__omp_current_phase__"] = str(title)
+        _emit_status("phase", title=str(title))
+        return None
+
+    class _Budget:
+        """Live view of the host Goal Mode token budget via the host bridge."""
+
+        @property
+        def total(self):
+            snap = _bridge_call("__budget__", {})
+            return (snap or {}).get("total")
+
+        @property
+        def hard(self):
+            snap = _bridge_call("__budget__", {})
+            return bool((snap or {}).get("hard"))
+
+        def spent(self):
+            snap = _bridge_call("__budget__", {})
+            return int((snap or {}).get("spent") or 0)
+
+        def remaining(self):
+            snap = _bridge_call("__budget__", {}) or {}
+            total = snap.get("total")
+            if total is None:
+                return math.inf
+            return max(0, total - int(snap.get("spent") or 0))
+
+        def __repr__(self):
+            try:
+                snap = _bridge_call("__budget__", {}) or {}
+                return f"<budget total={snap.get('total')} spent={snap.get('spent')}>"
+            except Exception:
+                return "<budget unavailable>"
+
+    budget = _Budget()

package/src/exec/bash-executor.ts

@@ -16,6 +16,7 @@ export interface BashExecutorOptions {
 	cwd?: string;
 	timeout?: number;
 	onChunk?: (chunk: string) => void;
+	chunkThrottleMs?: number;
 	signal?: AbortSignal;
 	/** Session key suffix to isolate shell sessions per agent */
 	sessionKey?: string;
@@ -97,9 +98,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		artifactId: options?.artifactId,
 		headBytes: resolveOutputSinkHeadBytes(settings),
 		maxColumns: resolveOutputMaxColumns(settings),
-		// Throttle the streaming preview callback to avoid saturating the
-		// event loop when commands produce massive output (e.g. seq 1 50M).
-		chunkThrottleMs: options?.onChunk ? 50 : 0,
+		chunkThrottleMs: options?.onChunk ? (options.chunkThrottleMs ?? 50) : 0,
 	});
 
 	// sink.push() is synchronous — buffer management, counters, and onChunk

package/src/extensibility/custom-tools/types.ts

@@ -101,11 +101,11 @@ export type CustomToolSessionEvent =
 	| {
 			reason: "auto_compaction_start";
 			trigger: "threshold" | "overflow" | "idle" | "incomplete";
-			action: "context-full" | "handoff";
+			action: "context-full" | "handoff" | "shake" | "shake-summary";
 	  }
 	| {
 			reason: "auto_compaction_end";
-			action: "context-full" | "handoff";
+			action: "context-full" | "handoff" | "shake" | "shake-summary";
 			result: CompactionResult | undefined;
 			aborted: boolean;
 			willRetry: boolean;

package/src/extensibility/extensions/runner.ts

@@ -315,9 +315,15 @@ export class ExtensionRunner {
 		return tools;
 	}
 
-	getFlags(): Map<string, ExtensionFlag> {
+	/**
+	 * Aggregate the registered CLI flags across a set of extensions (last write
+	 * wins on name collision). Static so callers that need the flag set before a
+	 * runner exists — e.g. the CLI resolving `@file`/flag args before session
+	 * creation — share this exact logic instead of duplicating it.
+	 */
+	static aggregateFlags(extensions: readonly Extension[]): Map<string, ExtensionFlag> {
 		const allFlags = new Map<string, ExtensionFlag>();
-		for (const ext of this.extensions) {
+		for (const ext of extensions) {
 			for (const [name, flag] of ext.flags) {
 				allFlags.set(name, flag);
 			}
@@ -325,6 +331,10 @@ export class ExtensionRunner {
 		return allFlags;
 	}
 
+	getFlags(): Map<string, ExtensionFlag> {
+		return ExtensionRunner.aggregateFlags(this.extensions);
+	}
+
 	getFlagValues(): Map<string, boolean | string> {
 		return new Map(this.runtime.flagValues);
 	}