@oh-my-pi/pi-coding-agent 16.0.3 → 16.0.5

package/src/advisor/__tests__/advisor.test.ts

@@ -12,6 +12,7 @@ import {
 	AdvisorRuntime,
 	type AdvisorRuntimeHost,
 	formatAdvisorBatchContent,
+	isAdvisorInterruptImmuneTurnActive,
 	isInterruptingSeverity,
 	resolveAdvisorDeliveryChannel,
 } from "..";
@@ -124,6 +125,44 @@ describe("advisor", () => {
 			expect(isInterruptingSeverity(undefined)).toBe(false);
 		});
 
+		it("keeps the interrupt-immune turn fence half-open for the configured window", () => {
+			expect(
+				isAdvisorInterruptImmuneTurnActive({
+					completedTurns: 4,
+					immuneTurnStart: undefined,
+					immuneTurns: 2,
+				}),
+			).toBe(false);
+			expect(
+				isAdvisorInterruptImmuneTurnActive({
+					completedTurns: 4,
+					immuneTurnStart: 5,
+					immuneTurns: 0,
+				}),
+			).toBe(false);
+			expect(
+				isAdvisorInterruptImmuneTurnActive({
+					completedTurns: 4,
+					immuneTurnStart: 5,
+					immuneTurns: 2,
+				}),
+			).toBe(true);
+			expect(
+				isAdvisorInterruptImmuneTurnActive({
+					completedTurns: 6,
+					immuneTurnStart: 5,
+					immuneTurns: 2,
+				}),
+			).toBe(true);
+			expect(
+				isAdvisorInterruptImmuneTurnActive({
+					completedTurns: 7,
+					immuneTurnStart: 5,
+					immuneTurns: 2,
+				}),
+			).toBe(false);
+		});
+
 		it("wraps each note in an advisory tag with severity as an attribute and escapes the body", () => {
 			const content = formatAdvisorBatchContent([
 				{ note: "first note" },
@@ -688,6 +727,26 @@ describe("advisor", () => {
 			}
 		});
 
+		it("routes interrupting notes to the aside queue during immune turns without overriding preservation", () => {
+			expect(
+				resolveAdvisorDeliveryChannel({
+					severity: "concern",
+					autoResumeSuppressed: false,
+					streaming: true,
+					aborting: false,
+					interruptImmuneTurnActive: true,
+				}),
+			).toBe("aside");
+			expect(
+				resolveAdvisorDeliveryChannel({
+					severity: "blocker",
+					autoResumeSuppressed: true,
+					streaming: false,
+					aborting: false,
+					interruptImmuneTurnActive: true,
+				}),
+			).toBe("preserve");
+		});
 		it("preserves an interrupting note while suppressed AND idle (no auto-resume of a stopped run)", () => {
 			for (const severity of ["concern", "blocker"] as const) {
 				expect(

package/src/advisor/advise-tool.ts

@@ -68,6 +68,15 @@ export function isInterruptingSeverity(severity: AdvisorSeverity | undefined): b
 
 /** How an advisor note is routed to the primary. */
 export type AdvisorDeliveryChannel = "aside" | "steer" | "preserve";
+/** Half-open turn-count fence for the post-interrupt cooldown. */
+export function isAdvisorInterruptImmuneTurnActive(opts: {
+	completedTurns: number;
+	immuneTurnStart: number | undefined;
+	immuneTurns: number;
+}): boolean {
+	if (opts.immuneTurnStart === undefined || opts.immuneTurns <= 0) return false;
+	return opts.completedTurns < opts.immuneTurnStart + opts.immuneTurns;
+}
 
 /**
  * Decide how one advisor note reaches the primary agent.
@@ -84,15 +93,19 @@ export type AdvisorDeliveryChannel = "aside" | "steer" | "preserve";
  *   auto-resume anything, so it is delivered live. Parking it during an active
  *   run instead strands it (it never reaches the running agent) and the withheld
  *   notes dump as one burst at the next user prompt — the bug this guards.
+ * - During the post-interrupt immune-turn window, further `concern`/`blocker`
+ *   notes are downgraded to asides; suppression preservation still wins.
  */
 export function resolveAdvisorDeliveryChannel(opts: {
 	severity: AdvisorSeverity | undefined;
 	autoResumeSuppressed: boolean;
 	streaming: boolean;
 	aborting: boolean;
+	interruptImmuneTurnActive?: boolean;
 }): AdvisorDeliveryChannel {
 	if (!isInterruptingSeverity(opts.severity)) return "aside";
 	if (opts.autoResumeSuppressed && (opts.aborting || !opts.streaming)) return "preserve";
+	if (opts.interruptImmuneTurnActive) return "aside";
 	return "steer";
 }
 

package/src/cli/args.ts

@@ -28,11 +28,13 @@ export interface Args {
 	smol?: string;
 	slow?: string;
 	plan?: string;
+	maxTime?: number;
 	apiKey?: string;
 	systemPrompt?: string;
 	appendSystemPrompt?: string;
 	thinking?: Effort;
 	hideThinking?: boolean;
+	advisor?: boolean;
 	continue?: boolean;
 	resume?: string | true;
 	help?: boolean;
@@ -194,6 +196,8 @@ export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { ty
 			result.noPty = true;
 		} else if (arg === "--hide-thinking") {
 			result.hideThinking = true;
+		} else if (arg === "--advisor") {
+			result.advisor = true;
 		} else if (arg === "--print" || arg === "-p") {
 			result.print = true;
 		} else if (arg === "--no-extensions") {

package/src/cli/bench-cli.ts

@@ -17,7 +17,12 @@ import { formatDuration, getProjectDir } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import type { ApiKeyResolverModel } from "../config/api-key-resolver";
 import { type CanonicalModelQueryOptions, ModelRegistry } from "../config/model-registry";
-import { formatModelString, getModelMatchPreferences, resolveCliModel } from "../config/model-resolver";
+import {
+	formatModelSelectorValue,
+	formatModelString,
+	getModelMatchPreferences,
+	resolveCliModel,
+} from "../config/model-resolver";
 import { Settings } from "../config/settings";
 import benchPrompt from "../prompts/bench.md" with { type: "text" };
 import { discoverAuthStorage } from "../sdk";
@@ -144,9 +149,15 @@ function isFirstTokenEvent(event: AssistantMessageEvent): boolean {
  * latency does not dilute throughput. Falls back to total duration when the
  * response arrived as a single chunk (TTFT ~ duration).
  */
-function computeTokensPerSecond(outputTokens: number, durationMs: number, ttftMs: number): number {
+export function computeTokensPerSecond(
+	outputTokens: number,
+	durationMs: number,
+	ttftMs: number,
+	deltaChunkCount: number,
+): number {
 	const decodeMs = durationMs - ttftMs;
-	const windowMs = decodeMs > 0 ? decodeMs : durationMs;
+	// Fall back to total duration when the response arrived as a single chunk/non-streaming.
+	const windowMs = decodeMs > 0 && deltaChunkCount >= 2 ? decodeMs : durationMs;
 	return windowMs > 0 ? (outputTokens * 1000) / windowMs : 0;
 }
 
@@ -193,10 +204,17 @@ async function runBenchRequest(
 			headers: model.provider === "openrouter" ? { "X-OpenRouter-Cache": "false" } : undefined,
 		});
 		let message: AssistantMessage | undefined;
+		let deltaChunkCount = 0;
 		for await (const event of stream) {
 			if (firstTokenAt === undefined && isFirstTokenEvent(event)) {
 				firstTokenAt = now();
 			}
+			if (
+				(event.type === "text_delta" || event.type === "thinking_delta" || event.type === "toolcall_delta") &&
+				event.delta.length > 0
+			) {
+				deltaChunkCount++;
+			}
 			if (event.type === "error") {
 				return { ok: false, error: event.error.errorMessage ?? "request failed" };
 			}
@@ -218,7 +236,7 @@ async function runBenchRequest(
 			ttftMs,
 			durationMs,
 			outputTokens,
-			tokensPerSecond: computeTokensPerSecond(outputTokens, durationMs, ttftMs),
+			tokensPerSecond: computeTokensPerSecond(outputTokens, durationMs, ttftMs, deltaChunkCount),
 		};
 	} catch (error) {
 		return { ok: false, error: getErrorMessage(error) };
@@ -244,6 +262,10 @@ function buildModelReport(
 	return { selector, model: formatModelString(model), thinking, results, average };
 }
 
+function formatBenchModelLabel(report: BenchModelReport): string {
+	return formatModelSelectorValue(report.model, report.thinking);
+}
+
 function formatMs(ms: number): string {
 	return formatDuration(Math.max(0, Math.round(ms)));
 }
@@ -264,7 +286,7 @@ export function formatBenchTable(summary: BenchSummary): string {
 		return b.average.tokensPerSecond - a.average.tokensPerSecond;
 	});
 	const rows = ranked.map(report => ({
-		model: report.model,
+		model: formatBenchModelLabel(report),
 		ttft: report.average ? formatMs(report.average.ttftMs) : "-",
 		tps: report.average ? `${report.average.tokensPerSecond.toFixed(1)}/s` : "-",
 		tokens: report.average ? String(Math.round(report.average.outputTokens)) : "-",
@@ -382,8 +404,9 @@ export async function runBenchCommand(command: BenchCommandArgs, deps: BenchDepe
 		const reports: BenchModelReport[] = [];
 		for (const { selector, model, thinking } of targets) {
 			if (!json) {
-				const resolvedNote = selector === formatModelString(model) ? "" : chalk.dim(` (${selector})`);
-				writeStdout(`${chalk.bold(formatModelString(model))}${resolvedNote}\n`);
+				const resolvedModel = formatModelSelectorValue(formatModelString(model), thinking);
+				const resolvedNote = selector === resolvedModel ? "" : chalk.dim(` (${selector})`);
+				writeStdout(`${chalk.bold(resolvedModel)}${resolvedNote}\n`);
 			}
 			const results: BenchRunResult[] = [];
 			for (let index = 0; index < runs; index++) {

package/src/cli/flag-tables.ts

@@ -120,6 +120,14 @@ export const STRING_SETTERS: Record<string, StringSetter> = {
 	"--plan": (result, value) => {
 		result.plan = value;
 	},
+	"--max-time": (result, value, deps) => {
+		const seconds = Number(value);
+		if (Number.isFinite(seconds) && seconds > 0) {
+			result.maxTime = seconds;
+		} else {
+			deps.logger.warn("Invalid seconds passed to --max-time", { value });
+		}
+	},
 	"--api-key": (result, value) => {
 		result.apiKey = value;
 	},
@@ -260,6 +268,7 @@ export const VALUELESS_FLAGS: ReadonlySet<string> = new Set([
 	"--no-lsp",
 	"--no-pty",
 	"--hide-thinking",
+	"--advisor",
 	"--print",
 	"--no-extensions",
 	"--no-skills",

package/src/collab/host.ts

@@ -415,7 +415,7 @@ export class CollabHost {
 		// render exactly the same anchored, provider-real count the host's own
 		// status line shows.
 		const breakdown = this.#ctx.statusLine.getCachedContextBreakdown();
-		const tokens = breakdown.usedTokens;
+		const tokens = breakdown.usedTokens ?? 0;
 		return {
 			isStreaming: session.isStreaming,
 			isAborting: session.isAborting,
@@ -427,7 +427,7 @@ export class CollabHost {
 			contextUsage: {
 				tokens,
 				contextWindow: breakdown.contextWindow,
-				percent: tokens !== null && breakdown.contextWindow > 0 ? (tokens / breakdown.contextWindow) * 100 : null,
+				percent: breakdown.contextWindow > 0 ? (tokens / breakdown.contextWindow) * 100 : 0,
 			},
 			participants: this.participants,
 		};

package/src/commands/launch.ts

@@ -106,6 +106,9 @@ export default class Index extends Command {
 		"hide-thinking": Flags.boolean({
 			description: "Hide thinking blocks in TUI output (display only, does not disable model thinking)",
 		}),
+		advisor: Flags.boolean({
+			description: "Enable the advisor runtime (passively reviews each turn and injects notes)",
+		}),
 		hook: Flags.string({
 			description: "Load a hook/extension file (can be used multiple times)",
 			multiple: true,
@@ -133,6 +136,9 @@ export default class Index extends Command {
 		"no-title": Flags.boolean({
 			description: "Disable title auto-generation",
 		}),
+		"max-time": Flags.string({
+			description: "Stop the session after this many seconds",
+		}),
 		// `--auto-approve` / `--yolo`: declared here so oclif's auto-generated `--help` lists it.
 		// Runtime parsing happens in `cli/args.ts parseArgs` (line 176 in that file) — `runRootCommand`
 		// consumes the manual-parser output, not these oclif flag values. If you rename or remove

package/src/config/settings-schema.ts

@@ -106,7 +106,7 @@ export const TAB_METADATA: Record<SettingTab, { label: string; icon: `tab.${stri
  */
 export const TAB_GROUPS: Record<SettingTab, readonly string[]> = {
 	appearance: ["Theme", "Status Line", "Display", "Images"],
-	model: ["Thinking", "Sampling", "Prompt", "Retry & Fallback", "Advisor"],
+	model: ["Thinking", "Sampling", "Prompt", "Retry & Fallback", "Advisor", "Vision"],
 	interaction: [
 		"Input",
 		"Approvals",
@@ -117,6 +117,7 @@ export const TAB_GROUPS: Record<SettingTab, readonly string[]> = {
 		"Startup & Updates",
 		"Power (macOS)",
 		"Agent",
+		"Git",
 	],
 	context: ["General", "Compaction", "Rules (TTSR)", "Experimental"],
 	memory: ["General", "Auto-Learn", "Mnemopi", "Hindsight"],
@@ -414,7 +415,36 @@ export const SETTINGS_SCHEMA = {
 				"Pause the main agent for up to 30 seconds if the advisor falls behind by this many turns. Off disables catch-up delays.",
 		},
 	},
+	"advisor.immuneTurns": {
+		type: "number",
+		default: 1,
+		ui: {
+			tab: "model",
+			group: "Advisor",
+			label: "Advisor Immune Turns",
+			description:
+				"After an advisor concern or blocker interrupts, route further concerns/blockers non-interruptingly for this many primary turns.",
+			options: [
+				{ value: "0", label: "0 turns", description: "Allow every concern/blocker to interrupt." },
+				{ value: "1", label: "1 turn", description: "Default." },
+				{ value: "2", label: "2 turns" },
+				{ value: "3", label: "3 turns" },
+				{ value: "4", label: "4 turns" },
+				{ value: "5", label: "5 turns" },
+			],
+		},
+	},
 	shellPath: { type: "string", default: undefined },
+	"git.enabled": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "interaction",
+			group: "Git",
+			label: "Enable Git Integration",
+			description: "Show git branch, status, and PR information in the TUI and watch repository metadata.",
+		},
+	},
 
 	extensions: { type: "array", default: EMPTY_STRING_ARRAY },
 
@@ -712,6 +742,18 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"images.describeForTextModels": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "model",
+			group: "Vision",
+			label: "Describe Images for Text Models",
+			description:
+				"When an image is attached to a model without vision support, save it under local:// and inject a description from a vision-capable model instead of dropping it",
+		},
+	},
+
 	"tui.maxInlineImageColumns": {
 		type: "number",
 		default: 100,
@@ -757,6 +799,16 @@ export const SETTINGS_SCHEMA = {
 				"Wrap paths and URLs in OSC 8 hyperlinks for terminal-native click-to-open (auto: detect support; off: never; always: unconditional)",
 		},
 	},
+	"tui.tight": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "appearance",
+			group: "Display",
+			label: "Tight Layout",
+			description: "Remove the 1-character horizontal padding from the left and right of the terminal output",
+		},
+	},
 	// Display rendering
 	"display.tabWidth": {
 		type: "number",
@@ -1505,7 +1557,7 @@ export const SETTINGS_SCHEMA = {
 	// Context promotion
 	"contextPromotion.enabled": {
 		type: "boolean",
-		default: true,
+		default: false,
 		ui: {
 			tab: "context",
 			group: "General",
@@ -1769,6 +1821,7 @@ export const SETTINGS_SCHEMA = {
 			"qwen3",
 			"gemini",
 			"gemma",
+			"minimax",
 		] as const,
 		default: "auto",
 		ui: {
@@ -1795,6 +1848,7 @@ export const SETTINGS_SCHEMA = {
 				{ value: "qwen3", label: "Qwen3", description: "Use the Qwen3 owned dialect." },
 				{ value: "gemini", label: "Gemini", description: "Use the Gemini owned dialect." },
 				{ value: "gemma", label: "Gemma", description: "Use the Gemma owned dialect." },
+				{ value: "minimax", label: "MiniMax", description: "Use the MiniMax owned dialect." },
 			],
 		},
 	},
@@ -2658,7 +2712,7 @@ export const SETTINGS_SCHEMA = {
 			group: "Read Summaries",
 			label: "Read Summary Unfold Ceiling",
 			description:
-				"Hard ceiling on summary size while BFS-unfolding. An unfold that would exceed this is reverted and unfolding stops.",
+				"Hard ceiling on summary size while BFS-unfolding. An unfold whose revealed lines would exceed this is skipped (that span stays folded) and unfolding continues with the remaining spans.",
 		},
 	},
 
@@ -3857,6 +3911,34 @@ export const SETTINGS_SCHEMA = {
 			description: "Providers that web_search should never use, even as fallbacks",
 		},
 	},
+	"providers.antigravityEndpoint": {
+		type: "enum",
+		values: ["auto", "production", "sandbox"] as const,
+		default: "auto",
+		ui: {
+			tab: "providers",
+			group: "Services",
+			label: "Antigravity Endpoint Mode",
+			description: "Endpoint routing strategy for google-antigravity providers (chat, search, image, discovery)",
+			options: [
+				{
+					value: "auto",
+					label: "Auto",
+					description: "Try production endpoint, fail over to sandbox on 5xx/429",
+				},
+				{
+					value: "production",
+					label: "Production Only",
+					description: "Force production endpoint only",
+				},
+				{
+					value: "sandbox",
+					label: "Sandbox Only",
+					description: "Force sandbox endpoint only",
+				},
+			],
+		},
+	},
 	"providers.image": {
 		type: "enum",
 		values: ["auto", "openai", "antigravity", "xai", "gemini", "openrouter"] as const,

package/src/edit/file-snapshot-store.ts

@@ -116,6 +116,17 @@ export function parseSeenLinesFromHashlineBody(body: string): number[] {
 	return seen;
 }
 
+/** Merge explicit 1-indexed displayed lines into a recorded hashline snapshot. */
+export function recordSeenLines(
+	session: FileSnapshotStoreOwner,
+	absolutePath: string,
+	tag: string,
+	lines: readonly number[],
+): void {
+	if (lines.length === 0) return;
+	getFileSnapshotStore(session).recordSeenLines(canonicalSnapshotKey(absolutePath), tag, lines);
+}
+
 /**
  * Attach the lines a read displayed to the snapshot it minted, so the patcher
  * can reject edits anchored on lines the model never saw. Best-effort: a no-op
@@ -128,7 +139,5 @@ export function recordSeenLinesFromBody(
 	tag: string,
 	body: string,
 ): void {
-	const seen = parseSeenLinesFromHashlineBody(body);
-	if (seen.length === 0) return;
-	getFileSnapshotStore(session).recordSeenLines(canonicalSnapshotKey(absolutePath), tag, seen);
+	recordSeenLines(session, absolutePath, tag, parseSeenLinesFromHashlineBody(body));
 }

package/src/eval/py/runner.py

@@ -190,6 +190,11 @@ class _RunnerState:
 
 
 _CURRENT_RID: contextvars.ContextVar[str | None] = contextvars.ContextVar("omp_current_rid", default=None)
+_CURRENT_DISPLAYED_MATPLOTLIB_FIGURE_IDS: contextvars.ContextVar[set[int] | None] = contextvars.ContextVar(
+    "omp_displayed_matplotlib_figure_ids",
+    default=None,
+)
+
 
 _STATE = _RunnerState()
 
@@ -670,6 +675,36 @@ _REPR_MIMES = [
 ]
 
 
+def _is_matplotlib_figure(value: Any) -> bool:
+    figure_module = sys.modules.get("matplotlib.figure")
+    figure_cls = getattr(figure_module, "Figure", None)
+    if isinstance(figure_cls, type) and isinstance(value, figure_cls):
+        return True
+
+    value_type = type(value)
+    return value_type.__module__ == "matplotlib.figure" and value_type.__name__ == "Figure"
+
+
+def _matplotlib_figure_png(value: Any) -> str | None:
+    if not _is_matplotlib_figure(value):
+        return None
+
+    savefig = getattr(value, "savefig", None)
+    if not callable(savefig):
+        return None
+
+    try:
+        buf = io.BytesIO()
+        savefig(buf, format="png", bbox_inches="tight")
+    except Exception:
+        return None
+
+    displayed_ids = _CURRENT_DISPLAYED_MATPLOTLIB_FIGURE_IDS.get()
+    if displayed_ids is not None:
+        displayed_ids.add(id(value))
+    return base64.b64encode(buf.getvalue()).decode("ascii")
+
+
 def _coerce_image_bytes(value: Any) -> str:
     if isinstance(value, (bytes, bytearray)):
         return base64.b64encode(bytes(value)).decode("ascii")
@@ -685,6 +720,10 @@ def _mime_bundle(value: Any) -> dict:
     accessors, and always provides ``text/plain``.
     """
     bundle: dict[str, Any] = {}
+    matplotlib_png = _matplotlib_figure_png(value)
+    if matplotlib_png is not None:
+        bundle["image/png"] = matplotlib_png
+
 
     mimebundle = getattr(value, "_repr_mimebundle_", None)
     if callable(mimebundle):
@@ -758,6 +797,9 @@ def _flush_matplotlib_figures() -> None:
     for num in fignums:
         try:
             fig = plt.figure(num)
+            if id(fig) in (_CURRENT_DISPLAYED_MATPLOTLIB_FIGURE_IDS.get() or set()):
+                plt.close(fig)
+                continue
             buf = io.BytesIO()
             fig.savefig(buf, format="png", bbox_inches="tight")
             data = base64.b64encode(buf.getvalue()).decode("ascii")
@@ -978,6 +1020,7 @@ def _start_parent_watchdog() -> None:
 async def _handle_request_async(req: dict) -> None:
     rid = str(req.get("id"))
     token = _CURRENT_RID.set(rid)
+    displayed_matplotlib_token = _CURRENT_DISPLAYED_MATPLOTLIB_FIGURE_IDS.set(set())
     _STATE.capture_rid = rid
     _STATE.user_ns["__omp_run_id__"] = rid
     _STATE.cancel_requested = False
@@ -1046,6 +1089,7 @@ async def _handle_request_async(req: dict) -> None:
             _STATE.capture_rid = None
         _flush_stream_proxies(rid)
         _CURRENT_RID.reset(token)
+        _CURRENT_DISPLAYED_MATPLOTLIB_FIGURE_IDS.reset(displayed_matplotlib_token)
 
 
 def _emit_error(rid: str, exc: BaseException) -> None:

package/src/extensibility/extensions/runner.ts

@@ -46,6 +46,8 @@ import type {
 	SessionBeforeSwitchResult,
 	SessionBeforeTreeResult,
 	SessionCompactingResult,
+	SessionStopEvent,
+	SessionStopEventResult,
 	ToolCallEvent,
 	ToolCallEventResult,
 	ToolResultEvent,
@@ -135,7 +137,9 @@ type RunnerEmitResult<TEvent extends RunnerEmitEvent> = TEvent extends { type: "
 				? SessionBeforeTreeResult | undefined
 				: TEvent extends { type: "session.compacting" }
 					? SessionCompactingResult | undefined
-					: undefined;
+					: TEvent extends { type: "session_stop" }
+						? SessionStopEventResult | undefined
+						: undefined;
 
 export type NewSessionHandler = (options?: {
 	parentSession?: string;
@@ -322,6 +326,10 @@ export class ExtensionRunner {
 		await this.emit({ type: "credential_disabled", ...event });
 	}
 
+	async emitSessionStop(event: Omit<SessionStopEvent, "type">): Promise<SessionStopEventResult | undefined> {
+		return await this.emit({ type: "session_stop", ...event });
+	}
+
 	getUIContext(): ExtensionUIContext {
 		return this.#uiContext;
 	}
@@ -588,7 +596,7 @@ export class ExtensionRunner {
 
 	async emit<TEvent extends RunnerEmitEvent>(event: TEvent): Promise<RunnerEmitResult<TEvent>> {
 		const ctx = this.createContext();
-		let result: SessionBeforeEventResult | SessionCompactingResult | undefined;
+		let result: SessionBeforeEventResult | SessionCompactingResult | SessionStopEventResult | undefined;
 
 		if (this.#isSessionShutdownEvent(event)) {
 			const timeoutMs = handlerTimeoutForEvent(event.type);
@@ -627,6 +635,16 @@ export class ExtensionRunner {
 				if (event.type === "session.compacting" && handlerResult) {
 					result = handlerResult as SessionCompactingResult;
 				}
+
+				if (event.type === "session_stop" && handlerResult) {
+					result = handlerResult as SessionStopEventResult;
+					const hasContinuationContext =
+						(typeof result.additionalContext === "string" && result.additionalContext.length > 0) ||
+						(typeof result.reason === "string" && result.reason.length > 0);
+					if ((result.continue === true || result.decision === "block") && hasContinuationContext) {
+						return result as RunnerEmitResult<TEvent>;
+					}
+				}
 			}
 		}
 

package/src/extensibility/extensions/types.ts

@@ -82,6 +82,8 @@ import type {
 	SessionEvent,
 	SessionShutdownEvent,
 	SessionStartEvent,
+	SessionStopEvent,
+	SessionStopEventResult,
 	SessionSwitchEvent,
 	SessionTreeEvent,
 	TodoReminderEvent,
@@ -274,11 +276,11 @@ export interface ExtensionUIContext {
 // ============================================================================
 
 export interface ContextUsage {
-	/** Estimated context tokens, or null if unknown (e.g. right after compaction, before next LLM response). */
-	tokens: number | null;
+	/** Estimated context tokens. */
+	tokens: number;
 	contextWindow: number;
-	/** Context usage as percentage of context window, or null if tokens is unknown. */
-	percent: number | null;
+	/** Context usage as percentage of context window. */
+	percent: number;
 }
 
 export interface CompactOptions {
@@ -525,7 +527,14 @@ export interface BeforeAgentStartEvent {
 	systemPrompt: string[];
 }
 
-export type { AgentEndEvent, AgentStartEvent, TurnEndEvent, TurnStartEvent } from "../shared-events";
+export type {
+	AgentEndEvent,
+	AgentStartEvent,
+	SessionStopEvent,
+	SessionStopEventResult,
+	TurnEndEvent,
+	TurnStartEvent,
+} from "../shared-events";
 
 /** Fired when a message starts (user, assistant, or toolResult) */
 export interface MessageStartEvent {
@@ -802,6 +811,7 @@ export type ExtensionEvent =
 	| BeforeAgentStartEvent
 	| AgentStartEvent
 	| AgentEndEvent
+	| SessionStopEvent
 	| TurnStartEvent
 	| TurnEndEvent
 	| MessageStartEvent
@@ -978,6 +988,7 @@ export interface ExtensionAPI {
 	on(event: "before_agent_start", handler: ExtensionHandler<BeforeAgentStartEvent, BeforeAgentStartEventResult>): void;
 	on(event: "agent_start", handler: ExtensionHandler<AgentStartEvent>): void;
 	on(event: "agent_end", handler: ExtensionHandler<AgentEndEvent>): void;
+	on(event: "session_stop", handler: ExtensionHandler<SessionStopEvent, SessionStopEventResult>): void;
 	on(event: "turn_start", handler: ExtensionHandler<TurnStartEvent>): void;
 	on(event: "turn_end", handler: ExtensionHandler<TurnEndEvent>): void;
 	on(event: "message_start", handler: ExtensionHandler<MessageStartEvent>): void;