@xynogen/pix-runtime 0.7.0 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-runtime",
-	"version": "0.7.0",
+	"version": "0.8.1",
 	"description": "Pix shared runtime — versioned pix.json config, atomic persistence, typed change events",
 	"type": "module",
 	"main": "src/index.ts",

package/src/extension.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { bindHerdrNotify } from "./herdr-notify.ts";
-import { bindAgentStateEvents, resetAgentState } from "./herdr-state.ts";
+import { bindAgentStateEvents, resetAgentState, resetUnattendedState } from "./herdr-state.ts";
 import { once } from "./once.ts";
 import { registerPixCommand } from "./pix-command.ts";
 import { pixRuntime } from "./runtime.ts";
@@ -23,6 +23,7 @@ export default function registerRuntime(pi: ExtensionAPI): void {
 
 		let initialized = false;
 		pi.on("session_start", async () => {
+			resetUnattendedState(pi.events);
 			if (initialized) {
 				await runtime.reload({ origin: "reload", source: "session_start" });
 			} else {
@@ -34,6 +35,7 @@ export default function registerRuntime(pi: ExtensionAPI): void {
 
 		pi.on("session_shutdown", async () => {
 			resetAgentState(pi.events);
+			resetUnattendedState(pi.events);
 			unbindHerdrNotify();
 			unbindAgentState();
 			await runtime.flush();

package/src/herdr-state.ts

@@ -1,6 +1,7 @@
 import type { EventBus } from "@earendil-works/pi-coding-agent";
 
 export type PixAgentState = "working" | "blocked" | "idle";
+export type UnattendedMode = "off" | "afk" | "yolo";
 export type PixAgentStateEvent = {
 	state: PixAgentState;
 	message?: string;
@@ -12,6 +13,8 @@ type Entry = { source: string; message?: string };
 type Coordinator = {
 	activities: Map<symbol, Entry>;
 	blocks: Map<symbol, Entry>;
+	unattendedMode: UnattendedMode;
+	yoloConsent: boolean;
 };
 
 function coordinators(): WeakMap<EventBus, Coordinator> {
@@ -24,7 +27,12 @@ function coordinator(events: EventBus): Coordinator {
 	const registry = coordinators();
 	let state = registry.get(events);
 	if (!state) {
-		state = { activities: new Map(), blocks: new Map() };
+		state = {
+			activities: new Map(),
+			blocks: new Map(),
+			unattendedMode: "off",
+			yoloConsent: false,
+		};
 		registry.set(events, state);
 	}
 	return state;
@@ -100,6 +108,28 @@ export async function withAgentBlock<T>(
 	}
 }
 
+export function getUnattendedMode(events: EventBus): UnattendedMode {
+	return coordinator(events).unattendedMode;
+}
+
+export function setUnattendedMode(events: EventBus, mode: UnattendedMode): void {
+	coordinator(events).unattendedMode = mode;
+}
+
+export function hasYoloConsent(events: EventBus): boolean {
+	return coordinator(events).yoloConsent;
+}
+
+export function setYoloConsent(events: EventBus, consent: boolean): void {
+	coordinator(events).yoloConsent = consent;
+}
+
+export function resetUnattendedState(events: EventBus): void {
+	const state = coordinator(events);
+	state.unattendedMode = "off";
+	state.yoloConsent = false;
+}
+
 /** Bind state replay/reset to one Pi session lifecycle. */
 export function bindAgentStateEvents(events: EventBus): () => void {
 	const off = events.on("pix:agent-state:request", () => publish(events));

package/src/index.ts

@@ -11,9 +11,15 @@ export { bindHerdrNotify } from "./herdr-notify.ts";
 export {
 	beginAgentActivity,
 	bindAgentStateEvents,
+	getUnattendedMode,
+	hasYoloConsent,
 	type PixAgentState,
 	type PixAgentStateEvent,
 	resetAgentState,
+	resetUnattendedState,
+	setUnattendedMode,
+	setYoloConsent,
+	type UnattendedMode,
 	withAgentBlock,
 } from "./herdr-state.ts";
 export { ioTimeoutMs, ioTimeoutSignal } from "./io.ts";

package/src/pix-command.ts

@@ -205,6 +205,7 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 		handler: async (_args: string, ctx: ExtensionCommandContext) => {
 			// Re-parse pix.json so section parsers remain the single validation source.
 			await runtime.reload({ origin: "command", source: "pix" });
+			// SAFETY: Runtime UI supports custom overlays beyond the published command context type.
 			const ui = ctx.ui as unknown as {
 				custom?: (f: unknown, opts?: unknown) => Promise<unknown>;
 				notify(m: string, t?: "info" | "warning" | "error"): void;
@@ -227,8 +228,8 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 					done: (v: null) => void,
 				) => {
 					const guide = (key: string, action: string) =>
-						theme.fg("text", key) + theme.fg("dim", ` ${action}`);
-					const guideSep = theme.fg("dim", " · ");
+						theme.fg("text", key) + theme.fg("muted", ` ${action}`);
+					const guideSep = theme.fg("muted", " · ");
 					let selected = 0;
 					let bodyOffset = 0;
 					let visibleBodyLines = 1;
@@ -241,8 +242,11 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 						// Functional updater: the runtime queue serializes writes, and the
 						// callback sees the latest committed value — so rapid presses each
 						// advance exactly one step instead of collapsing on a stale snapshot.
-						const step = (current: unknown): unknown => {
-							const curVal = row.read(current);
+						type SettingsState = Record<string, unknown>;
+						const step = (current: unknown): SettingsState => {
+							const state: SettingsState =
+								current !== null && typeof current === "object" ? { ...(current as object) } : {};
+							const curVal = row.read(state);
 							let cur = row.values.indexOf(curVal);
 							// ponytail: unsupported custom values snap to section default on first change.
 							if (cur === -1) {
@@ -252,8 +256,8 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 							}
 							const next = (cur + direction + row.values.length) % row.values.length;
 							const val = row.values[next];
-							if (val === undefined) return current;
-							return { ...(current as object), ...(row.patch(val) as object) };
+							if (val === undefined) return state;
+							return { ...state, ...(row.patch(val) as object) };
 						};
 						// Re-render AFTER the commit lands; the synchronous render in
 						// handleInput fires before the queued write and shows a stale value.