pi-plus 0.1.2 → 0.1.3

package/README.md

@@ -12,8 +12,8 @@ at CC's auto-compact threshold.
 
 | Behavior | CC source | Here |
 |---|---|---|
-| Context window resolution (env override → `[1m]` suffix → capability ≥100k → 200k default) | `utils/context.ts` | `src/model-config.ts` |
-| Max output tokens per model + 8k slot-reservation cap + env override | `utils/context.ts`, `services/api/claude.ts` | `src/model-config.ts` |
+| Context window resolution (`[1m]` suffix → capability ≥100k → 200k default) | `utils/context.ts` | `src/model-config.ts` |
+| Max output tokens per model + 8k slot-reservation cap | `utils/context.ts`, `services/api/claude.ts` | `src/model-config.ts` |
 | Effective window = window − min(maxOutput, 20k) | `services/compact/autoCompact.ts` | `src/model-config.ts` |
 | Auto-compact threshold = effective − 13,000 | `services/compact/autoCompact.ts` | `src/model-config.ts` |
 | Context measurement: last API usage (input+cacheWrite+cacheRead+output) + chars/4 tail estimate; images/PDFs flat 2000 | `utils/tokens.ts`, `services/tokenEstimation.ts` | `src/usage.ts` |
@@ -21,6 +21,12 @@ at CC's auto-compact threshold.
 | Warning/error/blocking thresholds (20k/20k/3k buffers) | `services/compact/autoCompact.ts` | `src/percentages.ts` |
 | Indicator text: dim `N% until auto-compact`, `Context low (N% remaining) · Run /compact to compact & continue` | `components/TokenWarning.tsx` | `src/indicator.ts` |
 
+This plugin supports **no Claude Code environment variables**
+(`CLAUDE_CODE_*`, `DISABLE_COMPACT`, … are all ignored). All configuration is
+done through the settings system described below; the only env vars honored
+are the plugin's own kill-switches, `PI_PLUS_NO_AUTO_COMPACT` and
+`PI_PLUS_NO_LOG`.
+
 On a real session the plugin's token count matches pi's own `ctx.getContextUsage().tokens`
 exactly for the Anthropic-style usage shape (pi's `cacheWrite` already includes the 1h
 cache subset and `reasoning` ⊂ `output`, so the field-for-field sums coincide).
@@ -55,28 +61,58 @@ auto-compact and CC's autocompact use). The trigger is edge-triggered: it
 fires once per crossing and re-arms after post-compact usage drops below the
 threshold. Manual `/compact` keeps working.
 
-Set `PI_CC_CONTEXT_NO_AUTO_COMPACT=1` to disable the plugin's trigger (indicator only).
+Set `PI_PLUS_NO_AUTO_COMPACT=1` to disable the plugin's trigger (indicator only).
 
-## Environment variables
+## Configuration
 
-All CC variables are honored with CC's semantics:
+Settings are read through [pi-extension-settings](https://github.com/juanibiapina/pi-extension-settings)
+(the pi ecosystem's standard settings helpers — `getSetting()`), stored under a
+`pi-plus` section. Global values live in `~/.pi/agent/settings-extensions.json`,
+project values in `.pi/settings-extensions.json` (project wins per key). Values
+are strings; invalid or absent values fall back to the hardcoded CC-derived
+defaults. If `@juanibiapina/pi-extension-settings` is installed, the settings
+also appear in its `/extension-settings` UI.
 
-| Variable | Effect |
-|---|---|
-| `CLAUDE_CODE_MAX_CONTEXT_TOKENS` | Hard context-window override (highest precedence) |
-| `CLAUDE_CODE_DISABLE_1M_CONTEXT` | Clamp windows >200k to 200k; ignore `[1m]` |
-| `CLAUDE_CODE_AUTO_COMPACT_WINDOW` | Cap the window before threshold math |
-| `CLAUDE_CODE_MAX_OUTPUT_TOKENS` | Override max output tokens (bounded by model's limit) |
-| `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE` | Auto-compact threshold as % of effective window (testing) |
-| `CLAUDE_CODE_BLOCKING_LIMIT_OVERRIDE` | Override the blocking limit |
-| `DISABLE_COMPACT` / `DISABLE_AUTO_COMPACT` | CC-style auto-compact off (switches indicator to "Context low … Run /compact") |
+```json
+{
+  "pi-plus": {
+    "autoCompact": "true",
+    "contextWindow": "256000",
+    "autoCompactThreshold": "235000",
+    "autoCompactPercent": "50",
+    "autoCompactWindowCap": "200000",
+    "maxOutputTokens": "8192",
+    "disableOutputTokenCap": "false",
+    "blockingLimit": "190000"
+  }
+}
+```
 
-Plugin-specific:
+| Setting | Effect | Default |
+|---|---|---|
+| `autoCompact` | Master switch for the plugin's auto-compact trigger (`true`/`false`) | `true` |
+| `contextWindow` | Override the model-derived context window (tokens) | model default (200k) |
+| `autoCompactThreshold` | Absolute token threshold for auto-compact; wins over everything below | effective window − 13k |
+| `autoCompactPercent` | Threshold as % of effective window (1–100, for testing) | off |
+| `autoCompactWindowCap` | Cap the window before threshold math (tokens) | off |
+| `maxOutputTokens` | Override max output tokens (bounded by the model's limit) | 8k-capped model default |
+| `disableOutputTokenCap` | Use the model's native default max output instead of the 8k slot cap | `false` |
+| `blockingLimit` | Absolute token usage that blocks further work | effective window − 3k |
+
+## Usage-detection log
+
+Every usage check is appended as one JSON line to `pi-plus.log` inside pi's
+agent directory (`$PI_CODING_AGENT_DIR` or `~/.pi/agent`). Each line records
+the event (`usage_check` from the indicator or the auto-compact trigger,
+plus `auto_compact_fired` / `auto_compact_error`), the model, the measured
+token count, and the threshold/percent state:
+
+```json
+{"ts":"2026-09-17T13:06:11.672Z","event":"usage_check","source":"indicator","model":"kimi-k2","tokens":9977,"percentLeft":94,"aboveWarning":false,"aboveError":false,"aboveAutoCompact":false,"atBlockingLimit":false}
+```
 
-| Variable | Effect |
-|---|---|
-| `PI_CC_CONTEXT_DISABLE_OTK_CAP` | Disable the 8k slot-reservation cap on max output tokens |
-| `PI_CC_CONTEXT_NO_AUTO_COMPACT` | Never call `ctx.compact()` from the plugin |
+Logging is best-effort — a write failure never affects the host agent.
+Set `PI_PLUS_NO_LOG=1` to disable it.
 
 ## Known limits
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-plus",
-	"version": "0.1.2",
+	"version": "0.1.3",
 	"description": "Claude Code-exact context usage detection for pi (extension)",
 	"type": "module",
 	"pi": {
@@ -44,5 +44,8 @@
 	"peerDependencies": {
 		"@earendil-works/pi-ai": "*",
 		"@earendil-works/pi-coding-agent": "*"
+	},
+	"dependencies": {
+		"@juanibiapina/pi-extension-settings": "^0.10.0"
 	}
 }

package/src/index.ts

@@ -13,10 +13,13 @@
  */
 
 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 { getAutoCompactThreshold } from "./model-config.ts";
 import { isAutoCompactEnabled, calculateTokenWarningState } from "./percentages.ts";
 import { renderTokenWarning } from "./indicator.ts";
+import { appendUsageLog } from "./logger.ts";
+import { loadPiPlusSettings } from "./settings.ts";
 import { tokenCountWithEstimation, type RoughMessage } from "./usage.ts";
 
 const STATUS_KEY = "cc-context";
@@ -29,20 +32,90 @@ function branchMessages(ctx: ExtensionContext): RoughMessage[] {
 }
 
 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: "",
+			},
+		] 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 updateIndicator(ctx: ExtensionContext): void {
-		if (!ctx.hasUI) return;
 		const model = ctx.model;
 		if (!model) {
-			ctx.ui.setStatus(STATUS_KEY, undefined);
+			if (ctx.hasUI) ctx.ui.setStatus(STATUS_KEY, undefined);
 			return;
 		}
+		const settings = loadPiPlusSettings();
 		const tokenCount = tokenCountWithEstimation(branchMessages(ctx));
-		const state = calculateTokenWarningState(tokenCount, model.id, model.contextWindow, model.maxTokens);
-		ctx.ui.setStatus(STATUS_KEY, renderTokenWarning(state, isAutoCompactEnabled(), ctx.ui.theme));
+		const state = calculateTokenWarningState(tokenCount, model.id, model.contextWindow, model.maxTokens, settings);
+		appendUsageLog({
+			event: "usage_check",
+			source: "indicator",
+			model: model.id,
+			tokens: tokenCount,
+			percentLeft: state.percentLeft,
+			aboveWarning: state.isAboveWarningThreshold,
+			aboveError: state.isAboveErrorThreshold,
+			aboveAutoCompact: state.isAboveAutoCompactThreshold,
+			atBlockingLimit: state.isAtBlockingLimit,
+		});
+		if (!ctx.hasUI) return;
+		ctx.ui.setStatus(STATUS_KEY, renderTokenWarning(state, isAutoCompactEnabled(settings), ctx.ui.theme));
 	}
 
 	/**
@@ -51,22 +124,35 @@ export default function (pi: ExtensionAPI) {
 	 * (tool_execution_end) — pi performs the compaction between agent steps
 	 * and continues the turn with the compacted context.
 	 *
-	 * Set PI_CC_CONTEXT_NO_AUTO_COMPACT=1 to disable, and disable pi's
+	 * 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;
-		if (!isAutoCompactEnabled()) return;
-		if (process.env.PI_CC_CONTEXT_NO_AUTO_COMPACT !== undefined) return;
+		const settings = loadPiPlusSettings();
+		if (!isAutoCompactEnabled(settings)) return;
+		if (process.env.PI_PLUS_NO_AUTO_COMPACT !== undefined) return;
 		const tokenCount = tokenCountWithEstimation(branchMessages(ctx));
-		const threshold = getAutoCompactThreshold(model.id, model.contextWindow, model.maxTokens);
-		if (!shouldFireAutoCompact(compactTrigger, tokenCount, threshold)) return;
+		const threshold = getAutoCompactThreshold(model.id, model.contextWindow, model.maxTokens, settings);
+		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) });
 		}
 	}
 

package/src/logger.ts

@@ -0,0 +1,56 @@
+/**
+ * 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

@@ -5,6 +5,10 @@
  *  - 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;
@@ -17,41 +21,37 @@ const MAX_OUTPUT_TOKENS_UPPER_LIMIT = 64_000;
 
 const ONE_MILLION = 1_000_000;
 
-function isEnvTruthy(value: string | undefined): boolean {
-	return value !== undefined && value !== "" && value !== "0" && value.toLowerCase() !== "false";
-}
-
-function parsePositiveInt(raw: string | undefined): number | undefined {
-	if (raw === undefined || raw === "") return undefined;
-	const parsed = parseInt(raw, 10);
-	return !Number.isNaN(parsed) && parsed > 0 ? parsed : undefined;
-}
-
-export function is1mContextDisabled(): boolean {
-	return isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT);
+/** 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 !is1mContextDisabled() && /\[1m\]/i.test(modelId);
+	return /\[1m\]/i.test(modelId);
 }
 
 /**
  * CC: getContextWindowForModel.
- * Resolution order: CLAUDE_CODE_MAX_CONTEXT_TOKENS env override → `[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.
+ * 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 {
-	const override = parsePositiveInt(process.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS);
-	if (override) return override;
-
 	if (has1mContext(modelId)) return ONE_MILLION;
 
 	if (modelContextWindow && modelContextWindow >= 100_000) {
-		if (modelContextWindow > MODEL_CONTEXT_WINDOW_DEFAULT && is1mContextDisabled()) {
-			return MODEL_CONTEXT_WINDOW_DEFAULT;
-		}
 		return modelContextWindow;
 	}
 	return MODEL_CONTEXT_WINDOW_DEFAULT;
@@ -111,21 +111,23 @@ export function getModelMaxOutputTokens(
 
 /**
  * CC: getMaxOutputTokensForModel — applies the slot-reservation cap
- * (tengu_otk_slot_v1, live in current production builds: default output
- * dropped to 8k, over-limit requests get one clean retry at 64k), then the
- * CLAUDE_CODE_MAX_OUTPUT_TOKENS bounded env override.
+ * (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): number {
+export function getMaxOutputTokensForModel(
+	modelId: string,
+	modelMaxTokens?: number,
+	settings?: ModelConfigSettings,
+): number {
 	const { default: modelDefault, upperLimit } = getModelMaxOutputTokens(modelId, modelMaxTokens);
-	const capDisabled = isEnvTruthy(process.env.PI_CC_CONTEXT_DISABLE_OTK_CAP);
 	// Math.min keeps models with lower native defaults (e.g. claude-3-opus at
 	// 4k) at their native value.
-	const defaultTokens = capDisabled ? modelDefault : Math.min(modelDefault, CAPPED_DEFAULT_MAX_TOKENS);
+	const defaultTokens = settings?.disableOutputTokenCap
+		? modelDefault
+		: Math.min(modelDefault, CAPPED_DEFAULT_MAX_TOKENS);
 
-	const raw = process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS;
-	if (raw !== undefined) {
-		const parsed = parseInt(raw, 10);
-		if (!Number.isNaN(parsed) && parsed > 0) return Math.min(parsed, upperLimit);
+	if (settings?.maxOutputTokens !== undefined && settings.maxOutputTokens > 0) {
+		return Math.min(settings.maxOutputTokens, upperLimit);
 	}
 	return defaultTokens;
 }
@@ -133,44 +135,50 @@ export function getMaxOutputTokensForModel(modelId: string, modelMaxTokens?: num
 /**
  * CC: getEffectiveContextWindowSize — context window minus the reserved
  * output tokens (min(maxOutput, 20k)), optionally capped by
- * CLAUDE_CODE_AUTO_COMPACT_WINDOW.
+ * `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),
+		getMaxOutputTokensForModel(modelId, modelMaxTokens, settings),
 		COMPACT_MAX_OUTPUT_TOKENS,
 	);
-	let contextWindow = resolveContextWindow(modelId, modelContextWindow);
-	const autoCompactWindow = parsePositiveInt(process.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW);
-	if (autoCompactWindow) {
-		contextWindow = Math.min(contextWindow, autoCompactWindow);
+	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. CLAUDE_AUTOCOMPACT_PCT_OVERRIDE (1–100) lowers it for testing.
+ * 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 {
-	const effective = getEffectiveContextWindowSize(modelId, modelContextWindow, modelMaxTokens);
+	if (settings?.autoCompactThreshold !== undefined) return settings.autoCompactThreshold;
+	const effective = getEffectiveContextWindowSize(modelId, modelContextWindow, modelMaxTokens, settings);
 	const autocompactThreshold = effective - AUTOCOMPACT_BUFFER_TOKENS;
 
-	const envPercent = process.env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE;
-	if (envPercent !== undefined) {
-		const parsed = parseFloat(envPercent);
-		if (!Number.isNaN(parsed) && parsed > 0 && parsed <= 100) {
-			const percentageThreshold = Math.floor(effective * (parsed / 100));
-			return Math.min(percentageThreshold, autocompactThreshold);
-		}
+	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

@@ -4,11 +4,15 @@
  * 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";
 
@@ -16,17 +20,20 @@ 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 — DISABLE_COMPACT / DISABLE_AUTO_COMPACT env vars.
- * (CC also consults a user-config flag; pi has no extension-readable
- * equivalent, so this port is env-only and defaults to enabled.)
+ * 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(): boolean {
-	const raw = (name: string) => process.env[name];
-	const truthy = (v: string | undefined) => v !== undefined && v !== "" && v !== "0" && v.toLowerCase() !== "false";
-	if (truthy(raw("DISABLE_COMPACT"))) return false;
-	if (truthy(raw("DISABLE_AUTO_COMPACT"))) return false;
-	return true;
+export function isAutoCompactEnabled(settings?: Pick<PercentagesSettings, "autoCompact">): boolean {
+	return settings?.autoCompact !== false;
 }
 
 /**
@@ -58,17 +65,18 @@ export interface TokenWarningState {
  * 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 env overrides differ.
+ * identical unless overrides differ.
  */
 export function calculateTokenWarningState(
 	tokenUsage: number,
 	modelId: string,
 	modelContextWindow?: number,
 	modelMaxTokens?: number,
+	settings?: PercentagesSettings,
 ): TokenWarningState {
-	const autoCompact = isAutoCompactEnabled();
-	const autoCompactThreshold = getAutoCompactThreshold(modelId, modelContextWindow, modelMaxTokens);
-	const effectiveContextWindow = getEffectiveContextWindowSize(modelId, modelContextWindow, modelMaxTokens);
+	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));
@@ -77,10 +85,9 @@ export function calculateTokenWarningState(
 	const errorThreshold = threshold - ERROR_THRESHOLD_BUFFER_TOKENS;
 
 	const defaultBlockingLimit = effectiveContextWindow - MANUAL_COMPACT_BUFFER_TOKENS;
-	const parsedOverride = process.env.CLAUDE_CODE_BLOCKING_LIMIT_OVERRIDE
-		? parseInt(process.env.CLAUDE_CODE_BLOCKING_LIMIT_OVERRIDE, 10)
-		: NaN;
-	const blockingLimit = !Number.isNaN(parsedOverride) && parsedOverride > 0 ? parsedOverride : defaultBlockingLimit;
+	const configuredBlocking = settings?.blockingLimit;
+	const blockingLimit =
+		configuredBlocking !== undefined && configuredBlocking > 0 ? configuredBlocking : defaultBlockingLimit;
 
 	return {
 		percentLeft,

package/src/settings.ts

@@ -0,0 +1,97 @@
+/**
+ * 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;
+}
+
+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);
+
+	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;
+	return settings;
+}