@oh-my-pi/pi-coding-agent 16.1.0 → 16.1.1

package/dist/types/config/settings-schema.d.ts

@@ -138,44 +138,32 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Automatically resume the most recent session in the current directory";
         };
     };
-    readonly "power.preventIdleSleep": {
-        readonly type: "boolean";
-        readonly default: true;
-        readonly ui: {
-            readonly tab: "interaction";
-            readonly group: "Power (macOS)";
-            readonly label: "Prevent Idle Sleep";
-            readonly description: "Keep the system awake while a session is open (caffeinate -i)";
-        };
-    };
-    readonly "power.preventSystemSleep": {
-        readonly type: "boolean";
-        readonly default: false;
-        readonly ui: {
-            readonly tab: "interaction";
-            readonly group: "Power (macOS)";
-            readonly label: "Prevent System Sleep on AC";
-            readonly description: "Block all system sleep while on AC power (caffeinate -s)";
-        };
-    };
-    readonly "power.declareUserActive": {
-        readonly type: "boolean";
-        readonly default: false;
-        readonly ui: {
-            readonly tab: "interaction";
-            readonly group: "Power (macOS)";
-            readonly label: "Declare User Active";
-            readonly description: "Keep the display lit and treat the user as active (caffeinate -u)";
-        };
-    };
-    readonly "power.preventDisplaySleep": {
-        readonly type: "boolean";
-        readonly default: false;
+    readonly "power.sleepPrevention": {
+        readonly type: "enum";
+        readonly values: readonly ["off", "idle", "display", "system"];
+        readonly default: "idle";
         readonly ui: {
             readonly tab: "interaction";
             readonly group: "Power (macOS)";
-            readonly label: "Prevent Display Sleep";
-            readonly description: "Keep the display from idle-sleeping while a session is open (caffeinate -d)";
+            readonly label: "Sleep Prevention";
+            readonly description: "Prevent macOS sleep during active sessions. Each level is cumulative — it adds the flags of all lower levels.";
+            readonly options: readonly [{
+                readonly value: "off";
+                readonly label: "Off";
+                readonly description: "Do not prevent any sleep";
+            }, {
+                readonly value: "idle";
+                readonly label: "Prevent Idle Sleep";
+                readonly description: "Keep the system awake while a session is open (caffeinate -i)";
+            }, {
+                readonly value: "display";
+                readonly label: "Prevent Display Sleep";
+                readonly description: "Also keep the display from idle-sleeping (caffeinate -i -d)";
+            }, {
+                readonly value: "system";
+                readonly label: "Prevent System Sleep";
+                readonly description: "Also block all system sleep on AC and declare the user active (caffeinate -i -d -s -u)";
+            }];
         };
     };
     readonly "advisor.enabled": {
@@ -196,6 +184,7 @@ export declare const SETTINGS_SCHEMA: {
             readonly group: "Advisor";
             readonly label: "Advisor for Subagents";
             readonly description: "Also enable the advisor on spawned task/eval subagents.";
+            readonly condition: "advisorEnabled";
         };
     };
     readonly "advisor.syncBacklog": {
@@ -207,6 +196,7 @@ export declare const SETTINGS_SCHEMA: {
             readonly group: "Advisor";
             readonly label: "Advisor Sync Backlog";
             readonly description: "Pause the main agent for up to 30 seconds if the advisor falls behind by this many turns. Off disables catch-up delays.";
+            readonly condition: "advisorEnabled";
         };
     };
     readonly "advisor.immuneTurns": {
@@ -238,6 +228,7 @@ export declare const SETTINGS_SCHEMA: {
                 readonly value: "5";
                 readonly label: "5 turns";
             }];
+            readonly condition: "advisorEnabled";
         };
     };
     readonly shellPath: {
@@ -821,7 +812,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "display.cacheMissMarker": {
         readonly type: "boolean";
-        readonly default: true;
+        readonly default: false;
         readonly ui: {
             readonly tab: "appearance";
             readonly group: "Display";

package/dist/types/lsp/types.d.ts

@@ -259,7 +259,7 @@ export interface LspClient {
     diagnostics: Map<string, PublishedDiagnostics>;
     diagnosticsVersion: number;
     openFiles: Map<string, OpenFile>;
-    pendingRequests: Map<number, PendingRequest>;
+    pendingRequests: Map<number | string, PendingRequest>;
     messageBuffer: Uint8Array;
     isReading: boolean;
     /** Lifecycle state: "connecting" until initialize completes, then "ready"; "error" on init failure or reader death. */
@@ -275,15 +275,17 @@ export interface LspClient {
     /** Call to signal that project loading has completed */
     resolveProjectLoaded: () => void;
 }
+/** JSON-RPC request/response identifier accepted by LSP peers. */
+export type LspJsonRpcId = number | string;
 export interface LspJsonRpcRequest {
     jsonrpc: "2.0";
-    id: number;
+    id: LspJsonRpcId;
     method: string;
     params: unknown;
 }
 export interface LspJsonRpcResponse {
     jsonrpc: "2.0";
-    id?: number;
+    id?: LspJsonRpcId;
     result?: unknown;
     error?: {
         code: number;

package/dist/types/modes/components/cache-invalidation-marker.d.ts

@@ -13,8 +13,13 @@ export interface CacheInvalidation {
  * request reads nothing from cache and re-pays for the whole prompt. We detect
  * that as: the previous turn cached a meaningful prefix, yet this turn's
  * `cacheRead` collapsed to zero while it still reprocessed a non-trivial prompt.
- * Returns `undefined` (no marker) for the first turn, tiny contexts, and turns
- * that reused any cache.
+ * Returns `undefined` (no marker) for the first turn, tiny contexts, turns
+ * that reused any cache, and — crucially — turns on providers with *implicit*
+ * best-effort caching. Only an explicit, prefix-controlled cache (Anthropic /
+ * Bedrock `cache_control`) re-creates the prefix on a cold turn (`cacheWrite >
+ * 0`); implicit caches (Google / OpenAI / Fireworks) report `cacheWrite: 0` and
+ * drop `cacheRead` to zero intermittently as routine propagation noise that
+ * self-heals the next turn, so flagging it would be a false positive.
  */
 export declare function detectCacheInvalidation(prev: Usage | undefined, current: Usage): CacheInvalidation | undefined;
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.1.0",
+	"version": "16.1.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -48,17 +48,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.1.0",
-		"@oh-my-pi/omp-stats": "16.1.0",
-		"@oh-my-pi/pi-agent-core": "16.1.0",
-		"@oh-my-pi/pi-ai": "16.1.0",
-		"@oh-my-pi/pi-catalog": "16.1.0",
-		"@oh-my-pi/pi-mnemopi": "16.1.0",
-		"@oh-my-pi/pi-natives": "16.1.0",
-		"@oh-my-pi/pi-tui": "16.1.0",
-		"@oh-my-pi/pi-utils": "16.1.0",
-		"@oh-my-pi/pi-wire": "16.1.0",
-		"@oh-my-pi/snapcompact": "16.1.0",
+		"@oh-my-pi/hashline": "16.1.1",
+		"@oh-my-pi/omp-stats": "16.1.1",
+		"@oh-my-pi/pi-agent-core": "16.1.1",
+		"@oh-my-pi/pi-ai": "16.1.1",
+		"@oh-my-pi/pi-catalog": "16.1.1",
+		"@oh-my-pi/pi-mnemopi": "16.1.1",
+		"@oh-my-pi/pi-natives": "16.1.1",
+		"@oh-my-pi/pi-tui": "16.1.1",
+		"@oh-my-pi/pi-utils": "16.1.1",
+		"@oh-my-pi/pi-wire": "16.1.1",
+		"@oh-my-pi/snapcompact": "16.1.1",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/config/settings-schema.ts

@@ -342,44 +342,38 @@ export const SETTINGS_SCHEMA = {
 	},
 
 	// macOS power assertions (caffeinate flags). No-op on other platforms.
-	"power.preventIdleSleep": {
-		type: "boolean",
-		default: true,
-		ui: {
-			tab: "interaction",
-			group: "Power (macOS)",
-			label: "Prevent Idle Sleep",
-			description: "Keep the system awake while a session is open (caffeinate -i)",
-		},
-	},
-	"power.preventSystemSleep": {
-		type: "boolean",
-		default: false,
-		ui: {
-			tab: "interaction",
-			group: "Power (macOS)",
-			label: "Prevent System Sleep on AC",
-			description: "Block all system sleep while on AC power (caffeinate -s)",
-		},
-	},
-	"power.declareUserActive": {
-		type: "boolean",
-		default: false,
-		ui: {
-			tab: "interaction",
-			group: "Power (macOS)",
-			label: "Declare User Active",
-			description: "Keep the display lit and treat the user as active (caffeinate -u)",
-		},
-	},
-	"power.preventDisplaySleep": {
-		type: "boolean",
-		default: false,
+	"power.sleepPrevention": {
+		type: "enum",
+		values: ["off", "idle", "display", "system"] as const,
+		default: "idle",
 		ui: {
 			tab: "interaction",
 			group: "Power (macOS)",
-			label: "Prevent Display Sleep",
-			description: "Keep the display from idle-sleeping while a session is open (caffeinate -d)",
+			label: "Sleep Prevention",
+			description:
+				"Prevent macOS sleep during active sessions. Each level is cumulative — it adds the flags of all lower levels.",
+			options: [
+				{
+					value: "off",
+					label: "Off",
+					description: "Do not prevent any sleep",
+				},
+				{
+					value: "idle",
+					label: "Prevent Idle Sleep",
+					description: "Keep the system awake while a session is open (caffeinate -i)",
+				},
+				{
+					value: "display",
+					label: "Prevent Display Sleep",
+					description: "Also keep the display from idle-sleeping (caffeinate -i -d)",
+				},
+				{
+					value: "system",
+					label: "Prevent System Sleep",
+					description: "Also block all system sleep on AC and declare the user active (caffeinate -i -d -s -u)",
+				},
+			],
 		},
 	},
 	"advisor.enabled": {
@@ -401,6 +395,7 @@ export const SETTINGS_SCHEMA = {
 			group: "Advisor",
 			label: "Advisor for Subagents",
 			description: "Also enable the advisor on spawned task/eval subagents.",
+			condition: "advisorEnabled",
 		},
 	},
 	"advisor.syncBacklog": {
@@ -413,6 +408,7 @@ export const SETTINGS_SCHEMA = {
 			label: "Advisor Sync Backlog",
 			description:
 				"Pause the main agent for up to 30 seconds if the advisor falls behind by this many turns. Off disables catch-up delays.",
+			condition: "advisorEnabled",
 		},
 	},
 	"advisor.immuneTurns": {
@@ -432,6 +428,7 @@ export const SETTINGS_SCHEMA = {
 				{ value: "4", label: "4 turns" },
 				{ value: "5", label: "5 turns" },
 			],
+			condition: "advisorEnabled",
 		},
 	},
 	shellPath: { type: "string", default: undefined },
@@ -851,7 +848,7 @@ export const SETTINGS_SCHEMA = {
 
 	"display.cacheMissMarker": {
 		type: "boolean",
-		default: true,
+		default: false,
 		ui: {
 			tab: "appearance",
 			group: "Display",

package/src/config/settings.ts

@@ -909,6 +909,46 @@ export class Settings {
 			}
 		}
 
+		// power.preventIdleSleep / power.preventSystemSleep / power.declareUserActive
+		// / power.preventDisplaySleep (four booleans) → power.sleepPrevention enum.
+		// The enum is cumulative: each level adds the flags of all lower levels.
+		// Migration picks the highest level whose condition is met, scanning from
+		// most to least aggressive so a single enum value captures the old state.
+		if (
+			!("sleepPrevention" in ((raw.power as Record<string, unknown>) ?? {})) &&
+			raw["power.sleepPrevention"] === undefined
+		) {
+			const powerObj = raw.power as Record<string, unknown> | undefined;
+			const getFlag = (key: string): boolean | undefined => {
+				const nested = powerObj?.[key];
+				const flat = raw[`power.${key}`];
+				const value = nested ?? flat;
+				return typeof value === "boolean" ? value : undefined;
+			};
+			const idle = getFlag("preventIdleSleep");
+			const system = getFlag("preventSystemSleep");
+			const user = getFlag("declareUserActive");
+			const display = getFlag("preventDisplaySleep");
+			const anySet = idle !== undefined || system !== undefined || user !== undefined || display !== undefined;
+			if (anySet) {
+				const mode = system || user ? "system" : display ? "display" : idle !== false ? "idle" : "off";
+				const powerRoot = (powerObj ?? {}) as Record<string, unknown>;
+				powerRoot.sleepPrevention = mode;
+				raw.power = powerRoot;
+			}
+			// Clean up old keys (nested + flat)
+			if (powerObj) {
+				delete powerObj.preventIdleSleep;
+				delete powerObj.preventSystemSleep;
+				delete powerObj.declareUserActive;
+				delete powerObj.preventDisplaySleep;
+			}
+			delete raw["power.preventIdleSleep"];
+			delete raw["power.preventSystemSleep"];
+			delete raw["power.declareUserActive"];
+			delete raw["power.preventDisplaySleep"];
+		}
+
 		return raw;
 	}
 

package/src/lsp/client.ts

@@ -5,6 +5,7 @@ import { applyWorkspaceEdit } from "./edits";
 import { getLspmuxCommand, isLspmuxSupported } from "./lspmux";
 import type {
 	LspClient,
+	LspJsonRpcId,
 	LspJsonRpcNotification,
 	LspJsonRpcRequest,
 	LspJsonRpcResponse,
@@ -416,7 +417,6 @@ function currentWorkspaceFolders(client: LspClient): Array<{ uri: string; name:
  * Handle workspace/workspaceFolders requests from the server.
  */
 async function handleWorkspaceFoldersRequest(client: LspClient, message: LspJsonRpcRequest): Promise<void> {
-	if (typeof message.id !== "number") return;
 	await sendResponse(client, message.id, currentWorkspaceFolders(client), "workspace/workspaceFolders");
 }
 
@@ -424,7 +424,6 @@ async function handleWorkspaceFoldersRequest(client: LspClient, message: LspJson
  * Handle workspace/configuration requests from the server.
  */
 async function handleConfigurationRequest(client: LspClient, message: LspJsonRpcRequest): Promise<void> {
-	if (typeof message.id !== "number") return;
 	const params = message.params as { items?: Array<{ section?: string }> };
 	const items = params?.items ?? [];
 	const result = items.map(item => {
@@ -438,7 +437,6 @@ async function handleConfigurationRequest(client: LspClient, message: LspJsonRpc
  * Handle workspace/applyEdit requests from the server.
  */
 async function handleApplyEditRequest(client: LspClient, message: LspJsonRpcRequest): Promise<void> {
-	if (typeof message.id !== "number") return;
 	const params = message.params as { edit?: WorkspaceEdit };
 	if (!params?.edit) {
 		await sendResponse(
@@ -475,13 +473,15 @@ async function handleServerRequest(client: LspClient, message: LspJsonRpcRequest
 		return;
 	}
 	if (message.method === "window/workDoneProgress/create") {
-		// Accept progress token registration from the server
-		if (typeof message.id === "number") {
-			await sendResponse(client, message.id, null, message.method);
-		}
+		// Accept progress token registration from the server.
+		await sendResponse(client, message.id, null, message.method);
+		return;
+	}
+	if (message.method === "client/registerCapability" || message.method === "client/unregisterCapability") {
+		// Some servers block semantic requests until dynamic registration succeeds.
+		await sendResponse(client, message.id, null, message.method);
 		return;
 	}
-	if (typeof message.id !== "number") return;
 	await sendResponse(client, message.id, null, message.method, {
 		code: -32601,
 		message: `Method not found: ${message.method}`,
@@ -493,7 +493,7 @@ async function handleServerRequest(client: LspClient, message: LspJsonRpcRequest
  */
 async function sendResponse(
 	client: LspClient,
-	id: number,
+	id: LspJsonRpcId,
 	result: unknown,
 	method: string,
 	error?: { code: number; message: string; data?: unknown },

package/src/lsp/types.ts

@@ -399,7 +399,7 @@ export interface LspClient {
 	diagnostics: Map<string, PublishedDiagnostics>;
 	diagnosticsVersion: number;
 	openFiles: Map<string, OpenFile>;
-	pendingRequests: Map<number, PendingRequest>;
+	pendingRequests: Map<number | string, PendingRequest>;
 	messageBuffer: Uint8Array;
 	isReading: boolean;
 	/** Lifecycle state: "connecting" until initialize completes, then "ready"; "error" on init failure or reader death. */
@@ -420,16 +420,19 @@ export interface LspClient {
 // JSON-RPC Protocol Types
 // =============================================================================
 
+/** JSON-RPC request/response identifier accepted by LSP peers. */
+export type LspJsonRpcId = number | string;
+
 export interface LspJsonRpcRequest {
 	jsonrpc: "2.0";
-	id: number;
+	id: LspJsonRpcId;
 	method: string;
 	params: unknown;
 }
 
 export interface LspJsonRpcResponse {
 	jsonrpc: "2.0";
-	id?: number;
+	id?: LspJsonRpcId;
 	result?: unknown;
 	error?: { code: number; message: string; data?: unknown };
 }

package/src/modes/components/cache-invalidation-marker.ts

@@ -25,8 +25,13 @@ export interface CacheInvalidation {
  * request reads nothing from cache and re-pays for the whole prompt. We detect
  * that as: the previous turn cached a meaningful prefix, yet this turn's
  * `cacheRead` collapsed to zero while it still reprocessed a non-trivial prompt.
- * Returns `undefined` (no marker) for the first turn, tiny contexts, and turns
- * that reused any cache.
+ * Returns `undefined` (no marker) for the first turn, tiny contexts, turns
+ * that reused any cache, and — crucially — turns on providers with *implicit*
+ * best-effort caching. Only an explicit, prefix-controlled cache (Anthropic /
+ * Bedrock `cache_control`) re-creates the prefix on a cold turn (`cacheWrite >
+ * 0`); implicit caches (Google / OpenAI / Fireworks) report `cacheWrite: 0` and
+ * drop `cacheRead` to zero intermittently as routine propagation noise that
+ * self-heals the next turn, so flagging it would be a false positive.
  */
 export function detectCacheInvalidation(prev: Usage | undefined, current: Usage): CacheInvalidation | undefined {
 	if (!prev) return undefined;
@@ -34,6 +39,11 @@ export function detectCacheInvalidation(prev: Usage | undefined, current: Usage)
 	if (prevFootprint < MIN_CACHE_FOOTPRINT) return undefined;
 	// Any cache reuse this turn means the prefix survived (at least partly).
 	if (current.cacheRead > 0) return undefined;
+	// Only an explicit, prefix-controlled cache re-creates the prefix on a cold
+	// turn — Anthropic/Bedrock report that as `cacheWrite`. Implicit best-effort
+	// caches (Google/OpenAI/Fireworks) report `cacheWrite: 0` and drop `cacheRead`
+	// to zero intermittently as propagation noise, not a real invalidation.
+	if (current.cacheWrite <= 0) return undefined;
 	const reprocessedTokens = current.cacheWrite + current.input;
 	if (reprocessedTokens < MIN_CACHE_FOOTPRINT) return undefined;
 	return { reprocessedTokens };

package/src/modes/components/settings-defs.ts

@@ -76,6 +76,13 @@ export type SettingDef = BooleanSettingDef | EnumSettingDef | SubmenuSettingDef
 
 const CONDITIONS: Record<string, () => boolean> = {
 	hasImageProtocol: () => !!TERMINAL.imageProtocol,
+	advisorEnabled: () => {
+		try {
+			return Settings.instance.get("advisor.enabled") === true;
+		} catch {
+			return false;
+		}
+	},
 	hindsightActive: () => {
 		try {
 			return Settings.instance.get("memory.backend") === "hindsight";

package/src/session/agent-session.ts

@@ -1344,19 +1344,15 @@ export class AgentSession {
 		if (process.platform !== "darwin") return;
 		if (isBunTestRuntime()) return;
 		if (this.#powerAssertion) return;
-		const idle = this.settings.get("power.preventIdleSleep");
-		const system = this.settings.get("power.preventSystemSleep");
-		const user = this.settings.get("power.declareUserActive");
-		const display = this.settings.get("power.preventDisplaySleep");
-		// All four off → user opted out; do nothing.
-		if (!idle && !system && !user && !display) return;
+		const mode = this.settings.get("power.sleepPrevention");
+		if (mode === "off") return;
 		try {
 			this.#powerAssertion = MacOSPowerAssertion.start({
 				reason: "Oh My Pi agent session",
-				idle,
-				system,
-				user,
-				display,
+				idle: true,
+				display: mode === "display" || mode === "system",
+				system: mode === "system",
+				user: mode === "system",
 			});
 		} catch (error) {
 			logger.warn("Failed to acquire macOS power assertion", { error: String(error) });