@xynogen/pix-commands 0.4.0 → 0.5.0

package/package.json

@@ -1,9 +1,13 @@
 {
 	"name": "@xynogen/pix-commands",
-	"version": "0.4.0",
+	"version": "0.5.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.6.0"
+		"@xynogen/pix-runtime": "^0.8.0"
 	}
 }

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.",