@xynogen/pix-commands 0.4.1 → 0.6.0

package/README.md

@@ -3,7 +3,7 @@
 Pi extension providing focused slash commands:
 
 - `/clear` — flush Pi's cached model data.
-- `/btw <question>` — ask an isolated side question without interrupting the main agent.
+- `/btw [--ctx] <question>` — ask an isolated side question without interrupting the main agent (`--ctx` folds in recent main-session turns).
 - `/afk` — toggle AFK mode for unattended runs (yellow auto-allow, red/root auto-deny).
 - `/yolo` — toggle YOLO mode for unattended runs (auto-approve nearly everything incl. red/root; capable models only, session consent required).
 
@@ -17,13 +17,19 @@ Deletes `~/.cache/pi` to flush stale model-data cache, then prompts you to run `
 
 ```text
 /btw what is the difference between a mutex and a semaphore?
+/btw --ctx given what we just did, what should I test first?
 ```
 
+Run `/btw` with no question to print usage. The live
+above-editor widget lingers finished asides for `collapse.delaySec × 3` (errors
+`× 9`), so a fire-and-leave aside stays visible while you are away; the durable
+answer card in the log never expires.
+
 The child session:
 
 - starts with an empty conversation and a lean Pix system prompt;
 - snapshots the main session's model, thinking level, active tools, credentials, extensions, and working directory;
-- never imports the main conversation;
+- never imports the main conversation **unless you pass `--ctx`**, which folds the last 10 main-session turns in as a one-shot, read-only preamble (visible in the question, still a fresh isolated session — nothing is written back to the main thread);
 - publishes its Markdown answer in a visually distinct side-thread card;
 - keeps rendered BTW answers out of future main-agent LLM context;
 - supports multiple concurrent side questions.

package/package.json

@@ -1,9 +1,13 @@
 {
 	"name": "@xynogen/pix-commands",
-	"version": "0.4.1",
+	"version": "0.6.0",
 	"description": "Pi extension — slash commands for cache clearing and isolated side questions",
 	"type": "module",
 	"main": "src/index.ts",
+	"exports": {
+		".": "./src/index.ts",
+		"./extension": "./src/extension.ts"
+	},
 	"scripts": {
 		"test": "bun test"
 	},
@@ -47,6 +51,6 @@
 	"dependencies": {
 		"@xynogen/pix-data": "^0.4.0",
 		"@xynogen/pix-pretty": "^1.13.0",
-		"@xynogen/pix-runtime": "^0.7.0"
+		"@xynogen/pix-runtime": "^0.8.0"
 	}
 }

package/src/btw/index.ts

@@ -6,8 +6,9 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import { Text, type TUI } from "@earendil-works/pi-tui";
 import { getSessionContextUsage } from "@xynogen/pix-pretty/widget-format";
+import { collapseDelayMs } from "@xynogen/pix-runtime/collapse";
 import { type BtwMessageDetails, registerBtwRenderer } from "./render.ts";
-import { runBtw, snapshotMainSettings } from "./session.ts";
+import { BTW_CTX_TURNS, buildContextPreamble, runBtw, snapshotMainSettings } from "./session.ts";
 import { type BtwWidgetJob, hasVisibleJobs, renderBtwWidget } from "./widget.ts";
 
 const STATUS_KEY = "pix-btw";
@@ -68,7 +69,8 @@ export function registerBtw(pi: ExtensionAPI): void {
 		if (!active || !latestUi) return;
 		const now = Date.now();
 		const allJobs = [...jobs.values()];
-		if (!hasVisibleJobs(allJobs.map(toWidgetJob), now)) {
+		const baseMs = collapseDelayMs();
+		if (!hasVisibleJobs(allJobs.map(toWidgetJob), now, baseMs)) {
 			latestUi.setStatus(STATUS_KEY, undefined);
 			latestUi.setWidget(WIDGET_KEY, undefined);
 			if (refreshTimer) clearInterval(refreshTimer);
@@ -85,7 +87,11 @@ export function registerBtw(pi: ExtensionAPI): void {
 					render: (width: number) => {
 						const w = width || tui.terminal.columns;
 						const widgetJobs = [...jobs.values()].map(toWidgetJob);
-						text.setText(renderBtwWidget(widgetJobs, theme, frame, Date.now(), w).join("\n"));
+						text.setText(
+							renderBtwWidget(widgetJobs, theme, frame, Date.now(), w, collapseDelayMs()).join(
+								"\n",
+							),
+						);
 						return text.render(w);
 					},
 					invalidate: () => text.invalidate(),
@@ -119,13 +125,29 @@ export function registerBtw(pi: ExtensionAPI): void {
 	pi.registerCommand("btw", {
 		description: "Ask an isolated side question without interrupting the main agent",
 		handler: async (rawArgs, ctx) => {
-			const question = rawArgs.trim();
 			latestUi = ctx.ui;
+
+			// Flag: --ctx folds in the last N main-session turns as read-only context.
+			const tokens = rawArgs.trim().split(/\s+/).filter(Boolean);
+			const withCtx = tokens.includes("--ctx");
+			const question = tokens.filter((t) => t !== "--ctx").join(" ");
+
 			if (!question) {
-				ctx.ui.notify("Usage: /btw <question>", "warning");
+				ctx.ui.notify(
+					[
+						"Usage: /btw [--ctx] <question>",
+						`  --ctx  include the last ${BTW_CTX_TURNS} main-session turns as read-only context`,
+						"By default the aside is fully isolated (sees no main conversation).",
+					].join("\n"),
+					"warning",
+				);
 				return;
 			}
 
+			const contextPreamble = withCtx
+				? buildContextPreamble(ctx.sessionManager.buildContextEntries())
+				: undefined;
+
 			let snapshot: ReturnType<typeof snapshotMainSettings>;
 			try {
 				snapshot = snapshotMainSettings(ctx, pi.getThinkingLevel(), pi.getActiveTools());
@@ -156,6 +178,7 @@ export function registerBtw(pi: ExtensionAPI): void {
 				question,
 				snapshot,
 				ctx,
+				contextPreamble,
 				onSession: (session) => {
 					job.session = session;
 				},

package/src/btw/session.test.ts

@@ -2,7 +2,9 @@ import { describe, expect, test } from "bun:test";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { LoadExtensionsResult } from "@earendil-works/pi-coding-agent";
 import {
+	BTW_CTX_TURNS,
 	BTW_SYSTEM_PROMPT,
+	buildContextPreamble,
 	lastAssistantText,
 	makeLeanExtensions,
 	selectBtwTools,
@@ -67,6 +69,43 @@ describe("makeLeanExtensions", () => {
 	});
 });
 
+describe("buildContextPreamble", () => {
+	const msg = (role: string, text: string) => ({
+		type: "message",
+		message: { role, content: [{ type: "text", text }] },
+	});
+
+	test("flattens recent user/assistant turns into a labeled preamble", () => {
+		const out = buildContextPreamble([msg("user", "hi"), msg("assistant", "hello")]);
+		expect(out).toContain("User: hi");
+		expect(out).toContain("Assistant: hello");
+		expect(out).toContain("read-only context");
+	});
+
+	test("keeps only the last N turns", () => {
+		const entries = Array.from({ length: BTW_CTX_TURNS + 5 }, (_, i) => msg("user", `q${i}`));
+		const out = buildContextPreamble(entries);
+		expect(out).not.toContain("q0"); // dropped
+		expect(out).toContain(`q${BTW_CTX_TURNS + 4}`); // kept
+		expect(out).toContain(`most recent ${BTW_CTX_TURNS} turn`);
+	});
+
+	test("skips non-message entries, tool noise, and string content", () => {
+		const out = buildContextPreamble([
+			{ type: "model_change", message: undefined },
+			{ type: "message", message: { role: "tool", content: "ignored" } },
+			{ type: "message", message: { role: "user", content: "plain string" } },
+		]);
+		expect(out).toContain("User: plain string");
+		expect(out).not.toContain("ignored");
+	});
+
+	test("returns empty when there are no usable turns", () => {
+		expect(buildContextPreamble([{ type: "compaction", message: undefined }])).toBe("");
+		expect(buildContextPreamble([])).toBe("");
+	});
+});
+
 describe("lastAssistantText", () => {
 	test("returns text from the latest assistant response", () => {
 		const messages = [

package/src/btw/session.ts

@@ -28,6 +28,8 @@ export interface BtwRunOptions {
 	question: string;
 	snapshot: BtwSnapshot;
 	ctx: ExtensionContext;
+	/** Optional read-only preamble (e.g. recent main-session turns from `--ctx`). */
+	contextPreamble?: string;
 	onSession?: (session: AgentSession) => void;
 	onTextDelta?: (delta: string, fullText: string) => void;
 	onToolStart?: (toolName: string) => void;
@@ -84,6 +86,59 @@ export function makeLeanExtensions(base: LoadExtensionsResult): LoadExtensionsRe
 	};
 }
 
+/** How many recent conversation turns `--ctx` folds into the aside. */
+export const BTW_CTX_TURNS = 10;
+
+/** One flattened conversation line: role + its text (tool noise dropped). */
+interface CtxLine {
+	role: string;
+	text: string;
+}
+
+/**
+ * Flatten the main session's recent user/assistant turns into a plain-text
+ * preamble for `--ctx`. Reads `buildContextEntries()` (the active,
+ * compaction-aware list), keeps only message entries with extractable text,
+ * and returns the last `turns` of them. Returns "" when there's nothing to show
+ * so callers can skip the preamble entirely.
+ *
+ * Kept a pure function over a minimal entry shape (not the full SessionManager)
+ * so it unit-tests without a Pi host.
+ */
+export function buildContextPreamble(
+	entries: readonly { type: string; message?: unknown }[],
+	turns = BTW_CTX_TURNS,
+): string {
+	const lines: CtxLine[] = [];
+	for (const entry of entries) {
+		if (entry.type !== "message") continue;
+		const msg = entry.message as { role?: string; content?: unknown } | undefined;
+		if (!msg || (msg.role !== "user" && msg.role !== "assistant")) continue;
+		const text = extractMessageText(msg.content);
+		if (text) lines.push({ role: msg.role, text });
+	}
+	const recent = lines.slice(-Math.max(1, turns));
+	if (recent.length === 0) return "";
+	const body = recent
+		.map((l) => `${l.role === "user" ? "User" : "Assistant"}: ${l.text}`)
+		.join("\n\n");
+	return `Recent conversation from the main session (most recent ${recent.length} turn(s), read-only context):\n\n${body}`;
+}
+
+/** Pull plain text out of a message's content (string or content-block array). */
+function extractMessageText(content: unknown): string {
+	if (typeof content === "string") return content.trim();
+	if (!Array.isArray(content)) return "";
+	return content
+		.filter((b): b is { type: "text"; text: string } => {
+			const block = b as { type?: string; text?: unknown };
+			return block.type === "text" && typeof block.text === "string";
+		})
+		.map((b) => b.text)
+		.join("\n")
+		.trim();
+}
+
 /** Extract the final assistant text if no streaming deltas were observed. */
 export function lastAssistantText(messages: readonly unknown[]): string {
 	for (let index = messages.length - 1; index >= 0; index--) {
@@ -171,8 +226,11 @@ export async function runBtw(options: BtwRunOptions): Promise<BtwRunResult> {
 		}
 	});
 
+	const prompt = options.contextPreamble
+		? `${options.contextPreamble}\n\n---\n\nQuestion: ${question}`
+		: question;
 	try {
-		await session.prompt(question, { source: "extension" });
+		await session.prompt(prompt, { source: "extension" });
 		return {
 			text: text.trim() || lastAssistantText(session.messages),
 			thinking: thinking.trim(),

package/src/btw/widget.test.ts

@@ -1,7 +1,11 @@
 import { describe, expect, test } from "bun:test";
 import {
 	type BtwWidgetJob,
+	DEFAULT_LINGER_BASE_MS,
+	ERROR_LINGER_SCALE,
 	hasVisibleJobs,
+	lingerWindows,
+	OK_LINGER_SCALE,
 	renderBtwWidget,
 	shouldShowFinished,
 	type WidgetTheme,
@@ -47,8 +51,9 @@ describe("BTW widget layout", () => {
 
 	test("finished jobs linger with a check, then drop after the window", () => {
 		const done = job({ status: "completed", completedAt: 1_000, toolUses: 2, turnCount: 1 });
+		// Default base 10s × 3 = 30s ok-window.
 		expect(shouldShowFinished(done, 1_500)).toBe(true);
-		expect(shouldShowFinished(done, 10_000)).toBe(false);
+		expect(shouldShowFinished(done, 40_000)).toBe(false); // 39s elapsed > 30s window
 
 		const out = render([done], 1_500);
 		expect(out).toContain("\u2713");
@@ -58,8 +63,26 @@ describe("BTW widget layout", () => {
 
 	test("errors linger longer and show the message", () => {
 		const failed = job({ status: "error", completedAt: 1_000, error: "boom" });
-		expect(shouldShowFinished(failed, 6_000)).toBe(true); // past the 5s ok-window
-		expect(render([failed], 6_000)).toContain("boom");
+		// Default base 10s × 9 = 90s error-window; 40s elapsed is past ok (30s) but well inside error.
+		expect(shouldShowFinished(failed, 40_000)).toBe(true);
+		expect(render([failed], 40_000)).toContain("boom");
+	});
+
+	test("linger windows scale off the config collapse delay", () => {
+		// Defaults derive from the fallback base.
+		expect(lingerWindows()).toEqual({
+			ok: DEFAULT_LINGER_BASE_MS * OK_LINGER_SCALE,
+			error: DEFAULT_LINGER_BASE_MS * ERROR_LINGER_SCALE,
+		});
+		// A custom base (e.g. config collapse.delaySec = 4 → 4000ms) scales both.
+		expect(lingerWindows(4_000)).toEqual({ ok: 12_000, error: 36_000 });
+		// Non-positive base falls back to the default so windows never collapse to 0.
+		expect(lingerWindows(0)).toEqual(lingerWindows());
+
+		// shouldShowFinished honors the threaded base: a 4s base drops an ok job at 13s.
+		const done = job({ status: "completed", completedAt: 0 });
+		expect(shouldShowFinished(done, 11_000, 4_000)).toBe(true); // < 12s
+		expect(shouldShowFinished(done, 13_000, 4_000)).toBe(false); // > 12s
 	});
 
 	test("overflow collapses excess rows into a +N more line", () => {

package/src/btw/widget.ts

@@ -46,21 +46,45 @@ export interface WidgetTheme {
 }
 
 const MAX_WIDGET_LINES = 12;
-const FINISHED_LINGER_MS = 5_000;
-const ERROR_LINGER_MS = 15_000;
 const ERROR_STATUSES = new Set<BtwJobStatus>(["error", "stopped"]);
 
+// /btw is fire-and-leave, so a finished job lingers far longer than a normal
+// collapsing tool card. Both windows scale off the shared collapse delay
+// (config `collapse.delaySec`, default 10s) so one knob tunes everything:
+//   ok linger    = base × 3   (30s at default)
+//   error linger = base × 9   (90s at default)
+// The durable answer card in render.ts is the permanent record; these only
+// govern the transient above-editor line.
+export const OK_LINGER_SCALE = 3;
+export const ERROR_LINGER_SCALE = 9;
+/** Fallback base when no config delay is threaded in (pure-module/test use). */
+export const DEFAULT_LINGER_BASE_MS = 10_000;
+
+/** Resolve the ok/error linger windows from a base collapse delay. */
+export function lingerWindows(baseMs: number = DEFAULT_LINGER_BASE_MS): {
+	ok: number;
+	error: number;
+} {
+	const base = baseMs > 0 ? baseMs : DEFAULT_LINGER_BASE_MS;
+	return { ok: base * OK_LINGER_SCALE, error: base * ERROR_LINGER_SCALE };
+}
+
 /** True while a finished job should still linger in the widget. */
-export function shouldShowFinished(job: BtwWidgetJob, now: number): boolean {
+export function shouldShowFinished(job: BtwWidgetJob, now: number, baseMs?: number): boolean {
 	if (job.status === "running" || job.completedAt == null) return false;
-	const linger = ERROR_STATUSES.has(job.status) ? ERROR_LINGER_MS : FINISHED_LINGER_MS;
+	const w = lingerWindows(baseMs);
+	const linger = ERROR_STATUSES.has(job.status) ? w.error : w.ok;
 	return now - job.completedAt < linger;
 }
 
 /** Any job worth painting right now (running or lingering finished). */
-export function hasVisibleJobs(jobs: Iterable<BtwWidgetJob>, now: number): boolean {
+export function hasVisibleJobs(
+	jobs: Iterable<BtwWidgetJob>,
+	now: number,
+	baseMs?: number,
+): boolean {
 	for (const job of jobs) {
-		if (job.status === "running" || shouldShowFinished(job, now)) return true;
+		if (job.status === "running" || shouldShowFinished(job, now, baseMs)) return true;
 	}
 	return false;
 }
@@ -115,9 +139,10 @@ export function renderBtwWidget(
 	frame: number,
 	now: number,
 	width: number,
+	baseMs?: number,
 ): string[] {
 	const running = jobs.filter((j) => j.status === "running");
-	const finished = jobs.filter((j) => j.status !== "running" && shouldShowFinished(j, now));
+	const finished = jobs.filter((j) => j.status !== "running" && shouldShowFinished(j, now, baseMs));
 	if (running.length === 0 && finished.length === 0) return [];
 
 	const truncate = (line: string) => truncateToWidth(line, width);

package/src/extension.test.ts

@@ -1,12 +1,11 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createEventBus, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { icon } from "@xynogen/pix-pretty/icon-catalog";
+import { getUnattendedMode } from "@xynogen/pix-runtime";
 import extension from "./extension.ts";
 
 afterEach(() => {
 	delete (globalThis as { __pixOnce?: WeakMap<object, Set<string>> }).__pixOnce;
-	delete (globalThis as { __pixAfk?: boolean }).__pixAfk;
-	delete (globalThis as { __pixYolo?: boolean }).__pixYolo;
 });
 
 describe("pix-commands registration", () => {
@@ -15,6 +14,7 @@ describe("pix-commands registration", () => {
 		const handlers = new Map<string, (args: string, ctx: never) => Promise<void>>();
 		const renderers: string[] = [];
 		const pi = {
+			events: createEventBus(),
 			registerCommand(
 				name: string,
 				options: { handler?: (args: string, ctx: never) => Promise<void> },
@@ -63,12 +63,12 @@ describe("pix-commands registration", () => {
 		if (!handler) throw new Error("/afk not registered");
 
 		await handler("", ctx as never);
-		expect((globalThis as { __pixAfk?: boolean }).__pixAfk).toBe(true);
+		expect(getUnattendedMode(pi.events)).toBe("afk");
 		expect(statuses.at(-1)).toBe(`<error>${icon("afk")} AFK</error>`);
 		expect(notices.at(-1)).toContain("yellow gates auto-allow");
 
 		await handler("", ctx as never);
-		expect((globalThis as { __pixAfk?: boolean }).__pixAfk).toBe(false);
+		expect(getUnattendedMode(pi.events)).toBe("off");
 		expect(statuses.at(-1)).toBeUndefined();
 	});
 });

package/src/unattended.test.ts

@@ -1,4 +1,5 @@
-import { afterEach, describe, expect, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
+import { createEventBus } from "@earendil-works/pi-coding-agent";
 import {
 	confirmYoloConsent,
 	getMode,
@@ -8,26 +9,17 @@ import {
 	YOLO_MIN_SCORE,
 } from "./unattended.ts";
 
-type G = { __pixAfk?: boolean; __pixYolo?: boolean; __pixYoloConsent?: boolean };
-
-afterEach(() => {
-	delete (globalThis as G).__pixAfk;
-	delete (globalThis as G).__pixYolo;
-	delete (globalThis as G).__pixYoloConsent;
-});
-
 describe("unattended mode state", () => {
-	test("setMode keeps the two globals mutually exclusive", () => {
-		setMode("afk");
-		expect(getMode()).toBe("afk");
-		expect((globalThis as G).__pixYolo).toBe(false);
+	test("setMode updates one session", () => {
+		const events = createEventBus();
+		setMode(events, "afk");
+		expect(getMode(events)).toBe("afk");
 
-		setMode("yolo");
-		expect(getMode()).toBe("yolo");
-		expect((globalThis as G).__pixAfk).toBe(false);
+		setMode(events, "yolo");
+		expect(getMode(events)).toBe("yolo");
 
-		setMode("off");
-		expect(getMode()).toBe("off");
+		setMode(events, "off");
+		expect(getMode(events)).toBe("off");
 	});
 });
 
@@ -40,20 +32,23 @@ describe("modelScore", () => {
 
 describe("unattendedBanner", () => {
 	test("off => no banner", () => {
-		setMode("off");
-		expect(unattendedBanner()).toBeUndefined();
+		const events = createEventBus();
+		setMode(events, "off");
+		expect(unattendedBanner(events)).toBeUndefined();
 	});
 
 	test("afk banner names auto-deny of red and root", () => {
-		setMode("afk");
-		const b = unattendedBanner() ?? "";
+		const events = createEventBus();
+		setMode(events, "afk");
+		const b = unattendedBanner(events) ?? "";
 		expect(b).toContain('mode="afk"');
 		expect(b).toContain("auto-DENY");
 	});
 
 	test("yolo banner demands red/root self-justification", () => {
-		setMode("yolo");
-		const b = unattendedBanner() ?? "";
+		const events = createEventBus();
+		setMode(events, "yolo");
+		const b = unattendedBanner(events) ?? "";
 		expect(b).toContain('mode="yolo"');
 		expect(b).toContain("blast radius");
 		expect(b).toContain("reversible");
@@ -68,12 +63,14 @@ describe("YOLO score threshold", () => {
 
 describe("confirmYoloConsent (session gate)", () => {
 	test("short-circuits true once consent is recorded for the session", async () => {
-		(globalThis as G).__pixYoloConsent = true;
+		const events = createEventBus();
+		const { setYoloConsent } = await import("@xynogen/pix-runtime");
+		setYoloConsent(events, true);
 		// No ui passed: if it did not short-circuit it would return false.
-		expect(await confirmYoloConsent({})).toBe(true);
+		expect(await confirmYoloConsent(events, {})).toBe(true);
 	});
 
 	test("refuses when there is no ui to render the warning", async () => {
-		expect(await confirmYoloConsent({})).toBe(false);
+		expect(await confirmYoloConsent(createEventBus(), {})).toBe(false);
 	});
 });

package/src/unattended.ts

@@ -16,21 +16,21 @@
  *          cached PAM ticket; the password cannot be auto-typed).
  */
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { EventBus, ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { lookupBenchmark } from "@xynogen/pix-data";
 import { showOverlay } from "@xynogen/pix-pretty/gate-overlay";
 import { icon } from "@xynogen/pix-pretty/icon-catalog";
+import {
+	getUnattendedMode,
+	hasYoloConsent,
+	setUnattendedMode,
+	setYoloConsent,
+	type UnattendedMode,
+} from "@xynogen/pix-runtime";
 
 /** Minimum model score allowed to hold YOLO. Below this, red+root auto-approve is off-limits. */
 export const YOLO_MIN_SCORE = 75;
 
-export type UnattendedMode = "off" | "afk" | "yolo";
-type UnattendedGlobal = typeof globalThis & {
-	__pixAfk?: boolean;
-	__pixYolo?: boolean;
-	/** Session-scoped: user acknowledged the YOLO damage warning this session. */
-	__pixYoloConsent?: boolean;
-};
 type StatusUI = {
 	theme: { fg(color: "error", text: string): string };
 	setStatus(key: string, text: string | undefined): void;
@@ -40,21 +40,9 @@ type ModelCtx = { model?: { id?: string } };
 
 const STATUS_KEY = "unattended";
 
-export function getMode(): UnattendedMode {
-	const g = globalThis as UnattendedGlobal;
-	if (g.__pixYolo === true) return "yolo";
-	if (g.__pixAfk === true) return "afk";
-	return "off";
-}
-
-/** Set the mode; the two globals are mutually exclusive so gate/sudo never see both. */
-export function setMode(mode: UnattendedMode): void {
-	const g = globalThis as UnattendedGlobal;
-	g.__pixAfk = mode === "afk";
-	g.__pixYolo = mode === "yolo";
-}
+export { getUnattendedMode as getMode, setUnattendedMode as setMode };
 
-function syncStatus(ui: StatusUI): void {
+function syncStatus(events: EventBus, ui: StatusUI): void {
 	// ponytail: reuses the existing "afk"/"warn" glyphs instead of adding a YOLO
 	//           icon to pix-pretty (that is a public-API minor bump + approval).
 	const labels: Record<UnattendedMode, string | undefined> = {
@@ -62,7 +50,7 @@ function syncStatus(ui: StatusUI): void {
 		afk: `${icon("afk")} AFK`,
 		off: undefined,
 	};
-	const label = labels[getMode()];
+	const label = labels[getUnattendedMode(events)];
 	ui.setStatus(STATUS_KEY, label ? ui.theme.fg("error", label) : undefined);
 }
 
@@ -73,9 +61,8 @@ function syncStatus(ui: StatusUI): void {
  * across sessions — a fresh session asks again (moral speed-bump, not a
  * once-and-forget click-through).
  */
-export async function confirmYoloConsent(ctx: ModelCtx): Promise<boolean> {
-	const g = globalThis as UnattendedGlobal;
-	if (g.__pixYoloConsent === true) return true;
+export async function confirmYoloConsent(events: EventBus, ctx: ModelCtx): Promise<boolean> {
+	if (hasYoloConsent(events)) return true;
 	const ui = (ctx as { ui?: unknown }).ui as Parameters<typeof showOverlay>[0] | undefined;
 	if (!ui) return false;
 	const result = await showOverlay(ui, {
@@ -101,7 +88,7 @@ export async function confirmYoloConsent(ctx: ModelCtx): Promise<boolean> {
 		],
 	});
 	const ok = result.action === "approved";
-	if (ok) g.__pixYoloConsent = true;
+	if (ok) setYoloConsent(events, true);
 	return ok;
 }
 
@@ -116,8 +103,8 @@ export function modelScore(ctx: ModelCtx): number | null {
  * Per-turn awareness banner. Injected via `before_agent_start` so the model is
  * told, every turn, that the human safety net is off and what it now owns.
  */
-export function unattendedBanner(): string | undefined {
-	const mode = getMode();
+export function unattendedBanner(events: EventBus): string | undefined {
+	const mode = getUnattendedMode(events);
 	if (mode === "yolo") {
 		return [
 			'<pix-unattended mode="yolo">',
@@ -148,11 +135,11 @@ export function unattendedBanner(): string | undefined {
 }
 
 export default function registerUnattended(pi: ExtensionAPI): void {
-	pi.on("session_start", (_event, ctx) => syncStatus(ctx.ui));
+	pi.on("session_start", (_event, ctx) => syncStatus(pi.events, ctx.ui));
 
 	// Every turn: prepend the awareness banner while a mode is active.
-	pi.on("before_agent_start", async (event) => {
-		const banner = unattendedBanner();
+	pi.on("before_agent_start", (event) => {
+		const banner = unattendedBanner(pi.events);
 		if (!banner) return undefined;
 		const existing = (event as { systemPrompt?: string }).systemPrompt ?? "";
 		return { systemPrompt: `${banner}\n\n${existing}` };
@@ -161,9 +148,9 @@ export default function registerUnattended(pi: ExtensionAPI): void {
 	pi.registerCommand("afk", {
 		description: "Toggle AFK mode — yellow gates auto-allow; red and root auto-deny",
 		handler: async (_args, ctx) => {
-			const turningOn = getMode() !== "afk";
-			setMode(turningOn ? "afk" : "off");
-			syncStatus(ctx.ui);
+			const turningOn = getUnattendedMode(pi.events) !== "afk";
+			setUnattendedMode(pi.events, turningOn ? "afk" : "off");
+			syncStatus(pi.events, ctx.ui);
 			ctx.ui.notify(
 				turningOn
 					? "AFK mode on — yellow gates auto-allow; red and root auto-deny."
@@ -176,9 +163,9 @@ export default function registerUnattended(pi: ExtensionAPI): void {
 	pi.registerCommand("yolo", {
 		description: "Toggle YOLO mode — auto-approve everything including red and root",
 		handler: async (_args, ctx) => {
-			if (getMode() === "yolo") {
-				setMode("off");
-				syncStatus(ctx.ui);
+			if (getUnattendedMode(pi.events) === "yolo") {
+				setUnattendedMode(pi.events, "off");
+				syncStatus(pi.events, ctx.ui);
 				ctx.ui.notify("YOLO mode off — approval prompts restored.", "info");
 				return;
 			}
@@ -199,12 +186,12 @@ export default function registerUnattended(pi: ExtensionAPI): void {
 				);
 				return;
 			}
-			if (!(await confirmYoloConsent(ctx as ModelCtx))) {
+			if (!(await confirmYoloConsent(pi.events, ctx as ModelCtx))) {
 				ctx.ui.notify("YOLO cancelled — approval prompts remain in place.", "info");
 				return;
 			}
-			setMode("yolo");
-			syncStatus(ctx.ui);
+			setUnattendedMode(pi.events, "yolo");
+			syncStatus(pi.events, ctx.ui);
 			ctx.ui.notify(
 				`YOLO mode on (model score ${score}) — every gate including red and root ` +
 					"auto-approves. No human will stop a destructive action. You are accountable.",