pi-plus 0.1.8 → 0.1.10

package/src/index.ts

@@ -1,172 +0,0 @@
-/**
- * pi-plus: Claude Code-exact context usage detection.
- *
- * A pi extension that measures context usage with the same arithmetic as
- * Claude Code (usage-based prefix count + rough tail estimation, CC's context
- * window resolution and warning thresholds) and shows it in the footer's
- * context field via a custom footer. When pi's built-in auto-compaction is
- * disabled, the plugin takes over and calls ctx.compact() at CC's
- * auto-compact threshold (effective window − 13,000 tokens).
- *
- * Install: copy/symlink this repo's src into ~/.pi/agent/extensions/pi-plus/
- * or run `pi -e ./src/index.ts`.
- */
-
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { SettingDefinition } from "@juanibiapina/pi-extension-settings";
-import { initialTriggerState, shouldFireAutoCompact, type AutoCompactTriggerState } from "./auto-compact.ts";
-import { computePluginContextUsage } from "./context-usage.ts";
-import { installFooter } from "./footer.ts";
-import { isAutoCompactEnabled } from "./percentages.ts";
-import { appendUsageLog } from "./logger.ts";
-import { loadPiPlusSettings } from "./settings.ts";
-
-
-export default function (pi: ExtensionAPI) {
-	// Register our settings so they appear in the /extension-settings UI
-	// (provided by @juanibiapina/pi-extension-settings when installed).
-	pi.events.emit("pi-extension-settings:register", {
-		name: "pi-plus",
-		settings: [
-			{
-				id: "autoCompact",
-				label: "Auto-compact at threshold",
-				description: "Call /compact automatically when usage crosses the auto-compact threshold",
-				defaultValue: "true",
-				values: ["true", "false"],
-			},
-			{
-				id: "contextWindow",
-				label: "Context window override",
-				description: "Override the model-derived context window (tokens). Empty = model default.",
-				defaultValue: "",
-			},
-			{
-				id: "autoCompactThreshold",
-				label: "Auto-compact threshold",
-				description: "Absolute token threshold for auto-compact. Empty = effective window − 13k.",
-				defaultValue: "",
-			},
-			{
-				id: "autoCompactPercent",
-				label: "Auto-compact percent",
-				description: "Threshold as % of effective window (1–100, testing). Empty = off.",
-				defaultValue: "",
-			},
-			{
-				id: "autoCompactWindowCap",
-				label: "Auto-compact window cap",
-				description: "Cap the window before threshold math (tokens). Empty = off.",
-				defaultValue: "",
-			},
-			{
-				id: "maxOutputTokens",
-				label: "Max output tokens",
-				description: "Override max output tokens (bounded by the model's limit). Empty = default.",
-				defaultValue: "",
-			},
-			{
-				id: "disableOutputTokenCap",
-				label: "Disable 8k output cap",
-				description: "Use the model's native default max output instead of the 8k slot cap",
-				defaultValue: "false",
-				values: ["false", "true"],
-			},
-			{
-				id: "blockingLimit",
-				label: "Blocking limit",
-				description: "Absolute token usage that blocks further work. Empty = effective window − 3k.",
-				defaultValue: "",
-			},
-			{
-				id: "customFooter",
-				label: "Custom footer (context field)",
-				description:
-					"Replace pi's built-in footer so its context field shows pi-plus's CC-exact usage (% used of the auto-compact threshold). Takes effect on the next session or /reload.",
-				defaultValue: "true",
-				values: ["true", "false"],
-			},
-		] satisfies SettingDefinition[],
-	});
-
-	// Edge-trigger state for the CC-threshold auto-compact. Reset per session;
-	// re-arms automatically once post-compact usage drops below the threshold.
-	let compactTrigger: AutoCompactTriggerState = initialTriggerState();
-
-	function logUsageCheck(ctx: ExtensionContext): void {
-		const model = ctx.model;
-		if (!model) return;
-		const settings = loadPiPlusSettings();
-		const computed = computePluginContextUsage(ctx, settings);
-		if (!computed) return;
-		const state = computed.state;
-		appendUsageLog({
-			event: "usage_check",
-			source: "indicator",
-			model: model.id,
-			tokens: computed.tokens,
-			percentLeft: state.percentLeft,
-			aboveWarning: state.isAboveWarningThreshold,
-			aboveError: state.isAboveErrorThreshold,
-			aboveAutoCompact: state.isAboveAutoCompactThreshold,
-			atBlockingLimit: state.isAtBlockingLimit,
-		});
-	}
-
-	/**
-	 * Check the token overflow against CC's auto-compact threshold and fire
-	 * ctx.compact() on a fresh crossing. Called on every tool task finish
-	 * (tool_execution_end) — pi performs the compaction between agent steps
-	 * and continues the turn with the compacted context.
-	 *
-	 * Set PI_PLUS_NO_AUTO_COMPACT=1 to disable, and disable pi's
-	 * built-in auto-compaction (settings.json "compaction": {"enabled": false})
-	 * so this threshold governs instead of pi's window − 16,384.
-	 */
-	function maybeAutoCompact(ctx: ExtensionContext): void {
-		const model = ctx.model;
-		if (!model) return;
-		const settings = loadPiPlusSettings();
-		if (!isAutoCompactEnabled(settings)) return;
-		if (process.env.PI_PLUS_NO_AUTO_COMPACT !== undefined) return;
-		const computed = computePluginContextUsage(ctx, settings);
-		if (!computed) return;
-		const tokenCount = computed.tokens;
-		const threshold = computed.threshold;
-		const fired = shouldFireAutoCompact(compactTrigger, tokenCount, threshold);
-		appendUsageLog({
-			event: "usage_check",
-			source: "auto_compact",
-			model: model.id,
-			tokens: tokenCount,
-			threshold,
-			belowThreshold: tokenCount < threshold,
-			fired,
-		});
-		if (!fired) return;
-		try {
-			ctx.compact();
-			appendUsageLog({ event: "auto_compact_fired", model: model.id, tokens: tokenCount, threshold });
-		} catch (error) {
-			ctx.ui.notify?.(`pi-plus: auto-compact failed to start: ${String(error)}`, "warning");
-			appendUsageLog({ event: "auto_compact_error", model: model.id, error: String(error) });
-		}
-	}
-
-	pi.on("session_start", (_event, ctx) => {
-		compactTrigger = initialTriggerState();
-		installFooter(ctx);
-		logUsageCheck(ctx);
-		maybeAutoCompact(ctx);
-	});
-	pi.on("turn_end", (_event, ctx) => logUsageCheck(ctx));
-	pi.on("agent_settled", (_event, ctx) => logUsageCheck(ctx));
-	// Check token overflow on every tool task finish.
-	pi.on("tool_execution_end", (_event, ctx) => {
-		logUsageCheck(ctx);
-		maybeAutoCompact(ctx);
-	});
-	pi.on("message_end", (_event, ctx) => logUsageCheck(ctx));
-	pi.on("model_select", (_event, ctx) => logUsageCheck(ctx));
-	pi.on("session_compact", (_event, ctx) => logUsageCheck(ctx));
-}

package/src/logger.ts

@@ -1,56 +0,0 @@
-/**
- * Usage-detection logging to a log file inside pi's agent directory
- * (`$PI_CODING_AGENT_DIR` or `~/.pi/agent`, same resolution as pi's
- * getAgentDir() in coding-agent config.ts).
- *
- * pi itself has no general runtime agent log (only an on-demand debug log
- * and a TUI crash log), so this plugin appends its own `pi-plus.log` there.
- * Lines are JSON — one object per usage check — so they can be inspected or
- * replayed easily.
- *
- * Logging is strictly best-effort: any filesystem error is swallowed so the
- * plugin can never crash or disturb the host agent.
- */
-
-import { appendFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-/** Mirrors pi's ENV_AGENT_DIR (`PI_CODING_AGENT_DIR` for the stock build). */
-const ENV_AGENT_DIR = "PI_CODING_AGENT_DIR";
-
-/** Set PI_PLUS_NO_LOG=1 to disable file logging. */
-export function isLogEnabled(): boolean {
-	const v = process.env.PI_PLUS_NO_LOG;
-	return v === undefined || v === "" || v === "0" || v.toLowerCase() === "false";
-}
-
-function expandTildePath(p: string): string {
-	if (p === "~") return homedir();
-	if (p.startsWith("~/")) return join(homedir(), p.slice(2));
-	return p;
-}
-
-export function getAgentDir(): string {
-	const envDir = process.env[ENV_AGENT_DIR];
-	return envDir ? expandTildePath(envDir) : join(homedir(), ".pi", "agent");
-}
-
-export function getPiPlusLogPath(): string {
-	return join(getAgentDir(), "pi-plus.log");
-}
-
-export type UsageLogFields = Record<string, string | number | boolean | null | undefined>;
-
-export function formatUsageLogLine(fields: UsageLogFields): string {
-	return JSON.stringify({ ts: new Date().toISOString(), ...fields }) + "\n";
-}
-
-export function appendUsageLog(fields: UsageLogFields): void {
-	if (!isLogEnabled()) return;
-	try {
-		appendFileSync(getPiPlusLogPath(), formatUsageLogLine(fields));
-	} catch {
-		// Best-effort: never propagate logging failures into the host agent.
-	}
-}

package/src/model-config.ts

@@ -1,184 +0,0 @@
-/**
- * Ports of Claude Code's context-window and max-output-token resolution.
- *
- * Sources (claude-code repo):
- *  - src/utils/context.ts          — getContextWindowForModel, getModelMaxOutputTokens
- *  - src/services/api/claude.ts    — getMaxOutputTokensForModel (slot-reservation cap)
- *  - src/services/compact/autoCompact.ts — getEffectiveContextWindowSize, getAutoCompactThreshold
- *
- * This plugin intentionally supports NO environment variables (CC's
- * CLAUDE_CODE_* env overrides included). Everything user-configurable lives
- * in the `pi-plus` section of pi's settings.json — see settings.ts.
- */
-
-export const MODEL_CONTEXT_WINDOW_DEFAULT = 200_000;
-export const COMPACT_MAX_OUTPUT_TOKENS = 20_000;
-export const CAPPED_DEFAULT_MAX_TOKENS = 8_000;
-export const AUTOCOMPACT_BUFFER_TOKENS = 13_000;
-
-const MAX_OUTPUT_TOKENS_DEFAULT = 32_000;
-const MAX_OUTPUT_TOKENS_UPPER_LIMIT = 64_000;
-
-const ONE_MILLION = 1_000_000;
-
-/** The `pi-plus` settings.json section, as it affects model config. */
-export interface ModelConfigSettings {
-	/** Override the model-derived context window (tokens). */
-	contextWindow?: number;
-	/** Cap the window before threshold math (CC: CLAUDE_CODE_AUTO_COMPACT_WINDOW). */
-	autoCompactWindowCap?: number;
-	/** Override max output tokens, bounded by the model's upper limit. */
-	maxOutputTokens?: number;
-	/** Disable the 8k slot-reservation cap on default max output tokens. */
-	disableOutputTokenCap?: boolean;
-	/** Override the auto-compact threshold directly (absolute tokens). */
-	autoCompactThreshold?: number;
-	/** Threshold as a percent (1–100) of the effective window (testing). */
-	autoCompactPercent?: number;
-}
-
-/** CC: has1mContext — explicit `[1m]` model suffix opt-in. */
-export function has1mContext(modelId: string): boolean {
-	return /\[1m\]/i.test(modelId);
-}
-
-/**
- * CC: getContextWindowForModel.
- * Resolution order: `[1m]` suffix → model capability (pi's registry
- * `contextWindow` plays the role of CC's `max_input_tokens` capability,
- * with the same >= 100k gate) → 200k default.
- */
-export function resolveContextWindow(modelId: string, modelContextWindow?: number): number {
-	if (has1mContext(modelId)) return ONE_MILLION;
-
-	if (modelContextWindow && modelContextWindow >= 100_000) {
-		return modelContextWindow;
-	}
-	return MODEL_CONTEXT_WINDOW_DEFAULT;
-}
-
-/**
- * CC: getModelMaxOutputTokens — hardcoded per-model table, overridden by the
- * model capability's max_tokens (pi's registry `maxTokens`) when >= 4096.
- */
-export function getModelMaxOutputTokens(
-	modelId: string,
-	modelMaxTokens?: number,
-): { default: number; upperLimit: number } {
-	const m = modelId.toLowerCase();
-	let defaultTokens: number;
-	let upperLimit: number;
-
-	if (m.includes("opus-4-6")) {
-		defaultTokens = 64_000;
-		upperLimit = 128_000;
-	} else if (m.includes("sonnet-4-6")) {
-		defaultTokens = 32_000;
-		upperLimit = 128_000;
-	} else if (m.includes("opus-4-5") || m.includes("sonnet-4") || m.includes("haiku-4")) {
-		defaultTokens = 32_000;
-		upperLimit = 64_000;
-	} else if (m.includes("opus-4-1") || m.includes("opus-4")) {
-		defaultTokens = 32_000;
-		upperLimit = 32_000;
-	} else if (m.includes("claude-3-opus")) {
-		defaultTokens = 4_096;
-		upperLimit = 4_096;
-	} else if (m.includes("claude-3-sonnet")) {
-		defaultTokens = 8_192;
-		upperLimit = 8_192;
-	} else if (m.includes("claude-3-haiku")) {
-		defaultTokens = 4_096;
-		upperLimit = 4_096;
-	} else if (m.includes("3-5-sonnet") || m.includes("3-5-haiku")) {
-		defaultTokens = 8_192;
-		upperLimit = 8_192;
-	} else if (m.includes("3-7-sonnet")) {
-		defaultTokens = 32_000;
-		upperLimit = 64_000;
-	} else {
-		defaultTokens = MAX_OUTPUT_TOKENS_DEFAULT;
-		upperLimit = MAX_OUTPUT_TOKENS_UPPER_LIMIT;
-	}
-
-	if (modelMaxTokens && modelMaxTokens >= 4_096) {
-		upperLimit = modelMaxTokens;
-		defaultTokens = Math.min(defaultTokens, upperLimit);
-	}
-
-	return { default: defaultTokens, upperLimit };
-}
-
-/**
- * CC: getMaxOutputTokensForModel — applies the slot-reservation cap
- * (tengu_otk_slot_v1: default output dropped to 8k), unless disabled in
- * settings, then the `maxOutputTokens` bounded settings override.
- */
-export function getMaxOutputTokensForModel(
-	modelId: string,
-	modelMaxTokens?: number,
-	settings?: ModelConfigSettings,
-): number {
-	const { default: modelDefault, upperLimit } = getModelMaxOutputTokens(modelId, modelMaxTokens);
-	// Math.min keeps models with lower native defaults (e.g. claude-3-opus at
-	// 4k) at their native value.
-	const defaultTokens = settings?.disableOutputTokenCap
-		? modelDefault
-		: Math.min(modelDefault, CAPPED_DEFAULT_MAX_TOKENS);
-
-	if (settings?.maxOutputTokens !== undefined && settings.maxOutputTokens > 0) {
-		return Math.min(settings.maxOutputTokens, upperLimit);
-	}
-	return defaultTokens;
-}
-
-/**
- * CC: getEffectiveContextWindowSize — context window minus the reserved
- * output tokens (min(maxOutput, 20k)), optionally capped by
- * `autoCompactWindowCap` from settings.
- *
- * `settings.contextWindow` replaces the model-derived window first.
- */
-export function getEffectiveContextWindowSize(
-	modelId: string,
-	modelContextWindow?: number,
-	modelMaxTokens?: number,
-	settings?: ModelConfigSettings,
-): number {
-	const reservedTokensForSummary = Math.min(
-		getMaxOutputTokensForModel(modelId, modelMaxTokens, settings),
-		COMPACT_MAX_OUTPUT_TOKENS,
-	);
-	let contextWindow = settings?.contextWindow ?? resolveContextWindow(modelId, modelContextWindow);
-	const windowCap = settings?.autoCompactWindowCap;
-	if (windowCap !== undefined && windowCap > 0) {
-		contextWindow = Math.min(contextWindow, windowCap);
-	}
-	return contextWindow - reservedTokensForSummary;
-}
-
-/**
- * CC: getAutoCompactThreshold — effective window minus the 13k autocompact
- * buffer. `autoCompactPercent` (1–100) lowers it for testing.
- *
- * `settings.autoCompactThreshold` (absolute tokens) wins outright;
- * otherwise `settings.contextWindow` / `autoCompactWindowCap` feed the
- * CC math via getEffectiveContextWindowSize.
- */
-export function getAutoCompactThreshold(
-	modelId: string,
-	modelContextWindow?: number,
-	modelMaxTokens?: number,
-	settings?: ModelConfigSettings,
-): number {
-	if (settings?.autoCompactThreshold !== undefined) return settings.autoCompactThreshold;
-	const effective = getEffectiveContextWindowSize(modelId, modelContextWindow, modelMaxTokens, settings);
-	const autocompactThreshold = effective - AUTOCOMPACT_BUFFER_TOKENS;
-
-	const percent = settings?.autoCompactPercent;
-	if (percent !== undefined && !Number.isNaN(percent) && percent > 0 && percent <= 100) {
-		const percentageThreshold = Math.floor(effective * (percent / 100));
-		return Math.min(percentageThreshold, autocompactThreshold);
-	}
-	return autocompactThreshold;
-}

package/src/percentages.ts

@@ -1,99 +0,0 @@
-/**
- * Ports of Claude Code's statusline percentage and token-warning thresholds.
- *
- * Sources (claude-code repo):
- *  - src/utils/context.ts                   — calculateContextPercentages
- *  - src/services/compact/autoCompact.ts    — calculateTokenWarningState, isAutoCompactEnabled
- *
- * No environment variables: the auto-compact on/off switch and blocking-limit
- * override live in the `pi-plus` settings.json section (see settings.ts).
- */
-
-import {
-	getAutoCompactThreshold,
-	getEffectiveContextWindowSize,
-	type ModelConfigSettings,
-} from "./model-config.ts";
-import type { UsageSnapshot } from "./usage.ts";
-
-export const WARNING_THRESHOLD_BUFFER_TOKENS = 20_000;
-export const ERROR_THRESHOLD_BUFFER_TOKENS = 20_000;
-export const MANUAL_COMPACT_BUFFER_TOKENS = 3_000;
-
-/** pi-plus settings keys that affect the warning state. */
-export interface PercentagesSettings extends ModelConfigSettings {
-	/** Master switch for auto-compaction (default true). */
-	autoCompact?: boolean;
-	/** Override the blocking limit (absolute tokens). */
-	blockingLimit?: number;
-}
-
-/**
- * CC: isAutoCompactEnabled — CC consults env vars and a user-config flag;
- * this port uses only the `autoCompact` settings.json flag (default true).
- */
-export function isAutoCompactEnabled(settings?: Pick<PercentagesSettings, "autoCompact">): boolean {
-	return settings?.autoCompact !== false;
-}
-
-/**
- * CC: calculateContextPercentages — the statusline percentage. Numerator is
- * input + cache creation + cache read (output EXCLUDED), denominator is the
- * raw context window (not the effective one). pi's `cacheWrite` includes the
- * 1h cache subset, matching CC's cache_creation_input_tokens.
- */
-export function calculateContextPercentages(
-	currentUsage: Pick<UsageSnapshot, "input" | "cacheRead" | "cacheWrite"> | null,
-	contextWindowSize: number,
-): { used: number | null; remaining: number | null } {
-	if (!currentUsage) return { used: null, remaining: null };
-	const totalInputTokens = currentUsage.input + currentUsage.cacheWrite + currentUsage.cacheRead;
-	const usedPercentage = Math.round((totalInputTokens / contextWindowSize) * 100);
-	const clampedUsed = Math.min(100, Math.max(0, usedPercentage));
-	return { used: clampedUsed, remaining: 100 - clampedUsed };
-}
-
-export interface TokenWarningState {
-	percentLeft: number;
-	isAboveWarningThreshold: boolean;
-	isAboveErrorThreshold: boolean;
-	isAboveAutoCompactThreshold: boolean;
-	isAtBlockingLimit: boolean;
-}
-
-/**
- * CC: calculateTokenWarningState — percent left until the (auto-compact or
- * effective) threshold and the warning/error/blocking threshold crossings.
- * Warning and error buffers are both 20k in CC, so the two crossings are
- * identical unless overrides differ.
- */
-export function calculateTokenWarningState(
-	tokenUsage: number,
-	modelId: string,
-	modelContextWindow?: number,
-	modelMaxTokens?: number,
-	settings?: PercentagesSettings,
-): TokenWarningState {
-	const autoCompact = isAutoCompactEnabled(settings);
-	const autoCompactThreshold = getAutoCompactThreshold(modelId, modelContextWindow, modelMaxTokens, settings);
-	const effectiveContextWindow = getEffectiveContextWindowSize(modelId, modelContextWindow, modelMaxTokens, settings);
-	const threshold = autoCompact ? autoCompactThreshold : effectiveContextWindow;
-
-	const percentLeft = Math.max(0, Math.round(((threshold - tokenUsage) / threshold) * 100));
-
-	const warningThreshold = threshold - WARNING_THRESHOLD_BUFFER_TOKENS;
-	const errorThreshold = threshold - ERROR_THRESHOLD_BUFFER_TOKENS;
-
-	const defaultBlockingLimit = effectiveContextWindow - MANUAL_COMPACT_BUFFER_TOKENS;
-	const configuredBlocking = settings?.blockingLimit;
-	const blockingLimit =
-		configuredBlocking !== undefined && configuredBlocking > 0 ? configuredBlocking : defaultBlockingLimit;
-
-	return {
-		percentLeft,
-		isAboveWarningThreshold: tokenUsage >= warningThreshold,
-		isAboveErrorThreshold: tokenUsage >= errorThreshold,
-		isAboveAutoCompactThreshold: autoCompact && tokenUsage >= autoCompactThreshold,
-		isAtBlockingLimit: tokenUsage >= blockingLimit,
-	};
-}

package/src/settings.ts

@@ -1,101 +0,0 @@
-/**
- * pi-plus settings, read through the pi ecosystem's standard settings
- * functions (`getSetting` from @juanibiapina/pi-extension-settings) rather
- * than by locating settings files ourselves.
- *
- * Storage: global values live in `~/.pi/agent/settings-extensions.json`,
- * project values in `.pi/settings-extensions.json` (project wins) — both
- * under a `"pi-plus"` extension section:
- *
- * ```json
- * {
- *   "pi-plus": {
- *     "autoCompact": "true",
- *     "contextWindow": "256000",
- *     "autoCompactWindowCap": "200000",
- *     "maxOutputTokens": "8192",
- *     "disableOutputTokenCap": "false",
- *     "autoCompactThreshold": "235000",
- *     "autoCompactPercent": "50",
- *     "blockingLimit": "190000"
- *   }
- * }
- * ```
- *
- * Values are strings (the extension-settings convention); each accessor
- * below parses and validates. Unset or invalid values fall back to the
- * hardcoded CC-derived defaults in model-config.ts / percentages.ts.
- *
- * This plugin supports NO Claude Code environment variables — this settings
- * system is the only configuration surface. (The plugin's own
- * PI_PLUS_NO_AUTO_COMPACT and PI_PLUS_NO_LOG env switches live in index.ts /
- * logger.ts.)
- */
-
-import { getSetting, type SettingStorageOptions } from "@juanibiapina/pi-extension-settings";
-import type { ModelConfigSettings } from "./model-config.ts";
-
-export interface PiPlusSettings extends ModelConfigSettings {
-	/** Master switch for auto-compaction (default true). */
-	autoCompact?: boolean;
-	/** Override the blocking limit (absolute tokens). */
-	blockingLimit?: number;
-	/** Master switch for the custom footer takeover (default true). */
-	customFooter?: boolean;
-}
-
-const EXTENSION_NAME = "pi-plus";
-
-function raw(settingId: string, options?: SettingStorageOptions): string | undefined {
-	const value = getSetting(EXTENSION_NAME, settingId, undefined, options);
-	return value === undefined || value === "" ? undefined : value;
-}
-
-function positiveInt(settingId: string, options?: SettingStorageOptions): number | undefined {
-	const value = raw(settingId, options);
-	if (value === undefined) return undefined;
-	const parsed = Number(value);
-	if (!Number.isFinite(parsed) || parsed <= 0) return undefined;
-	return Math.floor(parsed);
-}
-
-function percentValue(settingId: string, options?: SettingStorageOptions): number | undefined {
-	const parsed = positiveInt(settingId, options);
-	if (parsed === undefined || parsed > 100) return undefined;
-	return parsed;
-}
-
-function booleanValue(settingId: string, options?: SettingStorageOptions): boolean | undefined {
-	const value = raw(settingId, options);
-	if (value === undefined) return undefined;
-	const normalized = value.trim().toLowerCase();
-	if (["true", "1", "yes", "on"].includes(normalized)) return true;
-	if (["false", "0", "no", "off"].includes(normalized)) return false;
-	return undefined;
-}
-
-/** Load the merged pi-plus settings (local overrides global). */
-export function loadPiPlusSettings(options?: SettingStorageOptions): PiPlusSettings {
-	const settings: PiPlusSettings = {};
-
-	const contextWindow = positiveInt("contextWindow", options);
-	const autoCompactWindowCap = positiveInt("autoCompactWindowCap", options);
-	const maxOutputTokens = positiveInt("maxOutputTokens", options);
-	const autoCompactThreshold = positiveInt("autoCompactThreshold", options);
-	const autoCompactPercent = percentValue("autoCompactPercent", options);
-	const blockingLimit = positiveInt("blockingLimit", options);
-	const autoCompact = booleanValue("autoCompact", options);
-	const disableOutputTokenCap = booleanValue("disableOutputTokenCap", options);
-	const customFooter = booleanValue("customFooter", options);
-
-	if (contextWindow !== undefined) settings.contextWindow = contextWindow;
-	if (autoCompactWindowCap !== undefined) settings.autoCompactWindowCap = autoCompactWindowCap;
-	if (maxOutputTokens !== undefined) settings.maxOutputTokens = maxOutputTokens;
-	if (autoCompactThreshold !== undefined) settings.autoCompactThreshold = autoCompactThreshold;
-	if (autoCompactPercent !== undefined) settings.autoCompactPercent = autoCompactPercent;
-	if (blockingLimit !== undefined) settings.blockingLimit = blockingLimit;
-	if (autoCompact !== undefined) settings.autoCompact = autoCompact;
-	if (disableOutputTokenCap !== undefined) settings.disableOutputTokenCap = disableOutputTokenCap;
-	if (customFooter !== undefined) settings.customFooter = customFooter;
-	return settings;
-}