@zigai/pi-mode 0.3.1 → 0.4.0

package/README.md

@@ -20,11 +20,32 @@ pi install npm:@zigai/pi-mode
 - Can show the current mode in the prompt editor border when enabled.
 - Colors the prompt editor border from the active mode, with an opt-in setting for thinking-derived border colors.
 
-Modes can store a provider, model, thinking level, and optional color. Project-local modes live in `.pi/modes.json` when present; otherwise global modes live in `~/.pi/agent/modes.json`.
-
-By default, Pi Mode does not print the mode name in the editor border. To opt in, toggle `Show mode name` from `/mode` → `Configure modes…`, or set `"modeShowName": true` in global `~/.pi/agent/settings.json` or trusted project `.pi/settings.json`. The `/mode` toggle writes to global settings.
-
-By default, Pi Mode uses the normal editor border color when the active mode does not define an explicit `color`. To opt in to thinking-derived border colors, toggle `Thinking border colors` from `/mode` → `Configure modes…`, or set `"modeUseThinkingBorderColors": true` in global `~/.pi/agent/settings.json` or trusted project `.pi/settings.json`. Explicit per-mode `color` values still apply.
+Modes can store a provider, model, thinking level, and optional color. By default, Pi Mode hides Pi's transient `Thinking level: …` status message because the active thinking level is already visible in the footer.
+
+## Configuration
+
+Configure global settings at `~/.pi/agent/pi-mode/config.json`.
+
+| Option                        | Type      | Default     | Description                                                                |
+| ----------------------------- | --------- | ----------- | -------------------------------------------------------------------------- |
+| `version`                     | `number`  | `1`         | Config format version.                                                     |
+| `currentMode`                 | `string`  | `"default"` | Mode selected at startup.                                                  |
+| `modeShowName`                | `boolean` | `false`     | Shows the current mode name in the prompt editor border.                   |
+| `modeUseThinkingBorderColors` | `boolean` | `false`     | Uses thinking-derived border colors when a mode has no explicit color.     |
+| `modeShowThinkingLevelStatus` | `boolean` | `false`     | Shows Pi's transient thinking-level status message.                        |
+| `modes`                       | `object`  | `{}`        | Named modes with optional `provider`, `modelId`, `thinkingLevel`, `color`. |
+
+```json
+{
+  "$schema": "./config.schema.json",
+  "version": 1,
+  "currentMode": "default",
+  "modeShowName": false,
+  "modeUseThinkingBorderColors": false,
+  "modeShowThinkingLevelStatus": false,
+  "modes": {}
+}
+```
 
 ## License
 

package/config.schema.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://raw.githubusercontent.com/zigai/pi-tweaks/main/packages/pi-mode/config.schema.json",
+  "title": "Pi mode config",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "$schema": { "type": "string" },
+    "version": { "type": "number", "default": 1 },
+    "currentMode": { "type": "string", "default": "default" },
+    "modeShowName": { "type": "boolean", "default": false },
+    "modeUseThinkingBorderColors": { "type": "boolean", "default": false },
+    "modeShowThinkingLevelStatus": { "type": "boolean", "default": false },
+    "modes": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "provider": { "type": "string" },
+          "modelId": { "type": "string" },
+          "thinkingLevel": {},
+          "color": { "type": "string" }
+        }
+      },
+      "default": {}
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigai/pi-mode",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Pi package that adds prompt modes for model and thinking-level switching.",
   "keywords": [
     "mode",
@@ -23,7 +23,8 @@
   },
   "files": [
     "src",
-    "README.md"
+    "README.md",
+    "*.json"
   ],
   "type": "module",
   "publishConfig": {

package/src/constants.ts

@@ -9,6 +9,8 @@ export const MODE_UI_SHOW_NAME_ON = "Show mode name: on";
 export const MODE_UI_SHOW_NAME_OFF = "Show mode name: off";
 export const MODE_UI_THINKING_COLORS_ON = "Thinking border colors: on";
 export const MODE_UI_THINKING_COLORS_OFF = "Thinking border colors: off";
+export const MODE_UI_THINKING_STATUS_ON = "Thinking level status: on";
+export const MODE_UI_THINKING_STATUS_OFF = "Thinking level status: off";
 export const MODE_UI_BACK = "Back";
 
 export const ALL_THINKING_LEVELS: ThinkingLevel[] = [

package/src/index.ts

@@ -8,8 +8,11 @@ import {
     selectModeUI,
 } from "./mode-state.ts";
 import { setSettingsContext } from "./settings.ts";
+import { applyThinkingLevelStatusPatch } from "./status.ts";
 
 export default function (pi: ExtensionAPI) {
+    void applyThinkingLevelStatusPatch();
+
     pi.registerCommand("mode", {
         description: "Select prompt mode",
         handler: async (args, ctx) => {

package/src/mode-state.ts

@@ -20,6 +20,8 @@ import {
     MODE_UI_SHOW_NAME_ON,
     MODE_UI_THINKING_COLORS_OFF,
     MODE_UI_THINKING_COLORS_ON,
+    MODE_UI_THINKING_STATUS_OFF,
+    MODE_UI_THINKING_STATUS_ON,
     THINKING_UNSET_LABEL,
 } from "./constants.ts";
 import {
@@ -28,12 +30,15 @@ import {
     getGlobalModesPath,
     getMtimeMs,
     getProjectModesPath,
+    scaffoldGlobalModesConfig,
     withFileLock,
 } from "./storage.ts";
 import {
     setShowModeName,
+    setShowThinkingLevelStatus,
     setUseThinkingBorderColors,
     shouldShowModeName,
+    shouldShowThinkingLevelStatus,
     shouldUseThinkingBorderColors,
 } from "./settings.ts";
 import type { ModeRuntime, ModesFile, ModesPatch, ModeSpec, ModeSpecPatch } from "./types.ts";
@@ -43,19 +48,29 @@ type ScopedModelItem = {
     thinkingLevel?: string;
 };
 
-const ModeSpecJsonSchema = Type.Object({
-    provider: Type.Optional(Type.String()),
-    modelId: Type.Optional(Type.String()),
-    thinkingLevel: Type.Optional(Type.Unknown()),
-    color: Type.Optional(Type.String()),
-});
-
-const ModesFileJsonSchema = Type.Object({
-    $schema: Type.Optional(Type.String()),
-    version: Type.Optional(Type.Number()),
-    currentMode: Type.Optional(Type.String()),
-    modes: Type.Optional(Type.Record(Type.String(), ModeSpecJsonSchema)),
-});
+const ModeSpecJsonSchema = Type.Object(
+    {
+        provider: Type.Optional(Type.String()),
+        modelId: Type.Optional(Type.String()),
+        thinkingLevel: Type.Optional(Type.Unknown()),
+        color: Type.Optional(Type.String()),
+    },
+    { additionalProperties: false },
+);
+
+const ModesFileJsonSchema = Type.Object(
+    {
+        $schema: Type.Optional(Type.String()),
+        version: Type.Optional(Type.Number()),
+        currentMode: Type.Optional(Type.String()),
+        modeShowName: Type.Optional(Type.Boolean()),
+        modeUseThinkingBorderColors: Type.Optional(Type.Boolean()),
+        modeShowThinkingLevelStatus: Type.Optional(Type.Boolean()),
+        modes: Type.Optional(Type.Record(Type.String(), ModeSpecJsonSchema)),
+    },
+    { additionalProperties: false },
+);
+const ConfigObjectSchema = ModesFileJsonSchema;
 
 type ModeSpecJson = Static<typeof ModeSpecJsonSchema>;
 type ModesFileJson = Static<typeof ModesFileJsonSchema>;
@@ -69,7 +84,11 @@ function formatSchemaPath(instancePath: string): string {
         .join(".");
 }
 
-function parseSchema(schema: TSchema, value: unknown, label: string): unknown {
+function parseSchema<Schema extends TSchema>(
+    schema: Schema,
+    value: unknown,
+    label: string,
+): Static<Schema> {
     const errors = [...Value.Errors(schema, value)];
     if (errors.length > 0) {
         const messages = errors
@@ -82,15 +101,39 @@ function parseSchema(schema: TSchema, value: unknown, label: string): unknown {
         throw new Error(`${label} is invalid: ${messages.join("; ")}${suffix}`);
     }
     const parsed: unknown = Value.Parse(schema, value);
-    return parsed;
+    // SAFETY: Value.Errors returned no schema violations, so Value.Parse returns
+    // the TypeBox static type represented by the same schema.
+    // oxlint-disable-next-line typescript/no-unsafe-return -- SAFETY: TypeBox exposes parsed schema output through a conditional static type that oxlint treats as any here.
+    return parsed as Static<Schema>;
 }
 
 function parseModesFileJson(value: unknown): ModesFileJson {
-    return parseSchema(ModesFileJsonSchema, value, "modes.json") as ModesFileJson;
+    return parseSchema(ModesFileJsonSchema, value, "pi-mode config.json");
+}
+
+function parseConfigObject(value: unknown, filePath: string): Record<string, unknown> {
+    return Object.fromEntries(Object.entries(parseSchema(ConfigObjectSchema, value, filePath)));
+}
+
+function cloneModeSpec(spec: ModeSpec): ModeSpec {
+    const cloned: ModeSpec = {};
+    if (spec.provider !== undefined) cloned.provider = spec.provider;
+    if (spec.modelId !== undefined) cloned.modelId = spec.modelId;
+    if (spec.thinkingLevel !== undefined) cloned.thinkingLevel = spec.thinkingLevel;
+    if (spec.color !== undefined) cloned.color = spec.color;
+    return cloned;
 }
 
 function cloneModesFile(file: ModesFile): ModesFile {
-    return JSON.parse(JSON.stringify(file)) as ModesFile;
+    const modes: Record<string, ModeSpec> = {};
+    for (const [name, spec] of Object.entries(file.modes)) {
+        modes[name] = cloneModeSpec(spec);
+    }
+    return {
+        version: file.version,
+        currentMode: file.currentMode,
+        modes,
+    };
 }
 
 function modeSpec(modes: Record<string, ModeSpec>, name: string): ModeSpec | undefined {
@@ -256,7 +299,10 @@ function ensureDefaultModeEntries(file: ModesFile, ctx: ExtensionContext, pi: Ex
     for (const name of DEFAULT_MODE_ORDER) {
         if (modeSpec(file.modes, name) === undefined) {
             const defaults = createDefaultModes(ctx, pi);
-            file.modes[name] = defaults.modes[name]!;
+            const defaultSpec = modeSpec(defaults.modes, name);
+            if (defaultSpec !== undefined) {
+                file.modes[name] = cloneModeSpec(defaultSpec);
+            }
         }
     }
 
@@ -286,9 +332,14 @@ async function loadModesFile(
     pi: ExtensionAPI,
     options?: { throwOnInvalid?: boolean },
 ): Promise<ModesFile> {
+    if (filePath === getGlobalModesPath()) {
+        await scaffoldGlobalModesConfig();
+    }
+
     try {
         const raw = await fs.readFile(filePath, "utf8");
-        const parsed = parseModesFileJson(JSON.parse(raw));
+        const parsedJson: unknown = JSON.parse(raw);
+        const parsed = parseModesFileJson(parsedJson);
         const currentMode = parsed.currentMode ?? "default";
         const modesRaw = parsed.modes ?? {};
 
@@ -311,8 +362,23 @@ async function loadModesFile(
     }
 }
 
+async function readConfigObject(filePath: string): Promise<Record<string, unknown>> {
+    try {
+        const raw = await fs.readFile(filePath, "utf8");
+        const parsedJson: unknown = JSON.parse(raw);
+        return parseConfigObject(parsedJson, filePath);
+    } catch (error: unknown) {
+        if (getLoadErrorCode(error) === "ENOENT") return {};
+        throwLoadError(filePath, error);
+    }
+}
+
 async function saveModesFile(filePath: string, data: ModesFile): Promise<void> {
-    await atomicWriteUtf8(filePath, JSON.stringify(data, null, 2) + "\n");
+    const config = await readConfigObject(filePath);
+    config.version = data.version;
+    config.currentMode = data.currentMode;
+    config.modes = data.modes;
+    await atomicWriteUtf8(filePath, JSON.stringify(config, null, 2) + "\n");
 }
 
 function orderedModeNames(modes: Record<string, ModeSpec>): string[] {
@@ -323,9 +389,19 @@ function formatModeLabel(mode: string): string {
     return mode;
 }
 
-async function resolveModesPath(cwd: string): Promise<string> {
-    const projectPath = getProjectModesPath(cwd);
-    if (await fileExists(projectPath)) return projectPath;
+type ProjectTrustContext = ExtensionContext & {
+    isProjectTrusted?: () => boolean;
+};
+
+function isProjectTrusted(ctx: ExtensionContext): boolean {
+    return (ctx as ProjectTrustContext).isProjectTrusted?.() ?? true;
+}
+
+async function resolveModesPath(ctx: ExtensionContext): Promise<string> {
+    if (isProjectTrusted(ctx)) {
+        const projectPath = getProjectModesPath(ctx.cwd);
+        if (await fileExists(projectPath)) return projectPath;
+    }
     return getGlobalModesPath();
 }
 
@@ -434,7 +510,7 @@ export function getModeBorderColor(
 }
 
 async function ensureRuntime(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
-    const filePath = await resolveModesPath(ctx.cwd);
+    const filePath = await resolveModesPath(ctx);
 
     const mtimeMs = await getMtimeMs(filePath);
     const filePathChanged = runtime.filePath !== filePath;
@@ -871,11 +947,16 @@ async function configureModesUI(pi: ExtensionAPI, ctx: ExtensionContext): Promis
         if (shouldUseThinkingBorderColors()) {
             thinkingColorsChoice = MODE_UI_THINKING_COLORS_ON;
         }
+        let thinkingStatusChoice = MODE_UI_THINKING_STATUS_OFF;
+        if (shouldShowThinkingLevelStatus()) {
+            thinkingStatusChoice = MODE_UI_THINKING_STATUS_ON;
+        }
         const choice = await ctx.ui.select("Configure modes", [
             ...names,
             MODE_UI_ADD,
             showModeNameChoice,
             thinkingColorsChoice,
+            thinkingStatusChoice,
             MODE_UI_BACK,
         ]);
         if (choice === undefined || choice.length === 0 || choice === MODE_UI_BACK) return;
@@ -925,6 +1006,25 @@ async function configureModesUI(pi: ExtensionAPI, ctx: ExtensionContext): Promis
             continue;
         }
 
+        if (choice === MODE_UI_THINKING_STATUS_ON || choice === MODE_UI_THINKING_STATUS_OFF) {
+            const next = !shouldShowThinkingLevelStatus();
+            try {
+                setShowThinkingLevelStatus(next);
+            } catch (error: unknown) {
+                ctx.ui.notify(
+                    `Thinking level status was not saved: ${errorMessage(error)}`,
+                    "error",
+                );
+                continue;
+            }
+            let displayState = "disabled";
+            if (next) {
+                displayState = "enabled";
+            }
+            ctx.ui.notify(`Thinking level status ${displayState}`, "info");
+            continue;
+        }
+
         await editModeUI(pi, ctx, choice);
     }
 }
@@ -992,8 +1092,11 @@ export async function cycleMode(
     if (runtime.currentMode === CUSTOM_MODE_NAME) {
         baseMode = runtime.lastRealMode;
     }
+    const fallbackMode = names[0];
+    if (fallbackMode === undefined) return;
+
     const index = Math.max(0, names.indexOf(baseMode));
-    const next = names[(index + direction + names.length) % names.length] ?? names[0]!;
+    const next = names[(index + direction + names.length) % names.length] ?? fallbackMode;
     await applyMode(pi, ctx, next);
 }
 

package/src/settings.ts

@@ -1,11 +1,10 @@
 import {
+    CONFIG_DIR_NAME,
     getAgentDir,
-    SettingsManager,
     type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import {
     closeSync,
-    existsSync,
     mkdirSync,
     openSync,
     readFileSync,
@@ -20,10 +19,35 @@ import { Value } from "typebox/value";
 
 export const SHOW_MODE_NAME_SETTINGS_KEY = "modeShowName";
 export const USE_THINKING_BORDER_COLORS_SETTINGS_KEY = "modeUseThinkingBorderColors";
+export const SHOW_THINKING_LEVEL_STATUS_SETTINGS_KEY = "modeShowThinkingLevelStatus";
 
 const SETTINGS_LOCK_TIMEOUT_MS = 5_000;
 const STALE_SETTINGS_LOCK_MS = 30_000;
-const SettingsObjectSchema = Type.Object({});
+const EXTENSION_ID = "pi-mode";
+const CONFIG_FILE = "config.json";
+const SCHEMA_FILE = "config.schema.json";
+const ModeSpecJsonSchema = Type.Object(
+    {
+        provider: Type.Optional(Type.String()),
+        modelId: Type.Optional(Type.String()),
+        thinkingLevel: Type.Optional(Type.Unknown()),
+        color: Type.Optional(Type.String()),
+    },
+    { additionalProperties: false },
+);
+
+const SettingsObjectSchema = Type.Object(
+    {
+        $schema: Type.Optional(Type.String()),
+        version: Type.Optional(Type.Number()),
+        currentMode: Type.Optional(Type.String()),
+        [SHOW_MODE_NAME_SETTINGS_KEY]: Type.Optional(Type.Boolean()),
+        [USE_THINKING_BORDER_COLORS_SETTINGS_KEY]: Type.Optional(Type.Boolean()),
+        [SHOW_THINKING_LEVEL_STATUS_SETTINGS_KEY]: Type.Optional(Type.Boolean()),
+        modes: Type.Optional(Type.Record(Type.String(), ModeSpecJsonSchema)),
+    },
+    { additionalProperties: false },
+);
 const BooleanSettingSchema = Type.Boolean();
 
 type SettingsReadContext = {
@@ -31,12 +55,22 @@ type SettingsReadContext = {
     projectTrusted: boolean;
 };
 
+const DEFAULT_MODE_CONFIG_FILE = {
+    $schema: `./${SCHEMA_FILE}`,
+    version: 1,
+    currentMode: "default",
+    [SHOW_MODE_NAME_SETTINGS_KEY]: false,
+    [USE_THINKING_BORDER_COLORS_SETTINGS_KEY]: false,
+    [SHOW_THINKING_LEVEL_STATUS_SETTINGS_KEY]: false,
+    modes: {},
+};
+
 let settingsReadContext: SettingsReadContext | undefined;
 let cachedSettings:
     | {
-          mtimeKey: string;
           showModeName: boolean;
           useThinkingBorderColors: boolean;
+          showThinkingLevelStatus: boolean;
       }
     | undefined;
 
@@ -63,14 +97,76 @@ export function setSettingsContext(ctx: ExtensionContext): void {
 }
 
 function getSettingsPath(): string {
-    return join(getAgentDir(), "settings.json");
+    return join(getAgentDir(), EXTENSION_ID, CONFIG_FILE);
+}
+
+function getSchemaPath(configPath: string): string {
+    return join(dirname(configPath), SCHEMA_FILE);
+}
+
+function writeIfMissing(filePath: string, content: string): void {
+    try {
+        mkdirSync(dirname(filePath), { recursive: true });
+        writeFileSync(filePath, content, { encoding: "utf8", flag: "wx" });
+    } catch (error: unknown) {
+        if (error instanceof Error && (error as NodeJS.ErrnoException).code === "EEXIST") return;
+        if (error instanceof Error) throw error;
+        throw new Error(String(error));
+    }
+}
+
+function refreshSchemaFile(filePath: string, content: string): void {
+    let temporaryPath: string | undefined;
+    try {
+        mkdirSync(dirname(filePath), { recursive: true });
+        try {
+            if (readFileSync(filePath, "utf8") === content) return;
+        } catch (error: unknown) {
+            if (!(error instanceof Error) || (error as NodeJS.ErrnoException).code !== "ENOENT") {
+                throw error;
+            }
+        }
+
+        const nextTemporaryPath = `${filePath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        writeFileSync(nextTemporaryPath, content, { encoding: "utf8", flag: "wx" });
+        temporaryPath = nextTemporaryPath;
+        renameSync(temporaryPath, filePath);
+        temporaryPath = undefined;
+    } catch (error: unknown) {
+        if (temporaryPath !== undefined) {
+            try {
+                unlinkSync(temporaryPath);
+            } catch {
+                // Ignore cleanup failure while reporting the original scaffold failure.
+            }
+        }
+        if (error instanceof Error) throw error;
+        throw new Error(String(error));
+    }
+}
+
+function readBundledSchema(): string | undefined {
+    try {
+        return readFileSync(new URL("../config.schema.json", import.meta.url), "utf8");
+    } catch {
+        return undefined;
+    }
+}
+
+function scaffoldGlobalConfig(): void {
+    const globalConfigPath = getSettingsPath();
+    const schema = readBundledSchema();
+    if (schema !== undefined) {
+        refreshSchemaFile(getSchemaPath(globalConfigPath), schema);
+    }
+    writeIfMissing(globalConfigPath, `${JSON.stringify(DEFAULT_MODE_CONFIG_FILE, null, 2)}\n`);
 }
 
 function getProjectSettingsPath(): string | undefined {
     if (settingsReadContext === undefined || !settingsReadContext.projectTrusted) {
         return undefined;
     }
-    return join(settingsReadContext.cwd, ".pi", "settings.json");
+    return join(settingsReadContext.cwd, CONFIG_DIR_NAME, EXTENSION_ID, CONFIG_FILE);
 }
 
 function getErrorCode(error: unknown): string | undefined {
@@ -185,20 +281,6 @@ function atomicWriteUtf8Sync(filePath: string, content: string): void {
     }
 }
 
-function getFileMtimeMs(filePath: string | undefined): number | null {
-    if (filePath === undefined) return null;
-    try {
-        if (!existsSync(filePath)) return null;
-        return statSync(filePath).mtimeMs;
-    } catch {
-        return null;
-    }
-}
-
-function getSettingsMtimeKey(): string {
-    return `${getFileMtimeMs(getSettingsPath())}:${getFileMtimeMs(getProjectSettingsPath())}`;
-}
-
 function formatSchemaPath(instancePath: string): string {
     if (instancePath.length === 0) return "root";
     return instancePath
@@ -222,27 +304,35 @@ function parseSettingsObject(value: unknown, settingsPath: string): Record<strin
             `${settingsPath} must contain a JSON object: ${messages.join("; ")}${suffix}`,
         );
     }
-    return { ...(Value.Parse(SettingsObjectSchema, value) as Record<string, unknown>) };
+    return Object.fromEntries(Object.entries(Value.Parse(SettingsObjectSchema, value)));
 }
 
-function readSettingsObject(options?: { throwOnInvalid?: boolean }): Record<string, unknown> {
-    const settingsPath = getSettingsPath();
+function readSettingsObject(
+    settingsPath: string,
+    options?: { throwOnInvalid?: boolean },
+): Record<string, unknown> {
+    if (settingsPath === getSettingsPath()) {
+        scaffoldGlobalConfig();
+    }
+
     try {
         const raw = readFileSync(settingsPath, "utf8");
-        return parseSettingsObject(JSON.parse(raw), settingsPath);
+        const parsedJson: unknown = JSON.parse(raw);
+        return parseSettingsObject(parsedJson, settingsPath);
     } catch (error: unknown) {
         if (getErrorCode(error) === "ENOENT") return {};
         if (options?.throwOnInvalid === true) throwError(error);
-        // Ignore malformed settings files while reading and fall back to defaults.
+        // Ignore malformed config files while reading and fall back to defaults.
     }
 
     return {};
 }
 
 function updateSettingsObject(update: (settings: Record<string, unknown>) => void): void {
+    scaffoldGlobalConfig();
     const settingsPath = getSettingsPath();
     withSettingsLock(settingsPath, () => {
-        const settings = readSettingsObject({ throwOnInvalid: true });
+        const settings = readSettingsObject(settingsPath, { throwOnInvalid: true });
         update(settings);
         atomicWriteUtf8Sync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
     });
@@ -261,39 +351,53 @@ function applyBooleanSetting(
 function readModeSettings(): {
     showModeName: boolean;
     useThinkingBorderColors: boolean;
+    showThinkingLevelStatus: boolean;
 } {
-    const mtimeKey = getSettingsMtimeKey();
-    if (cachedSettings?.mtimeKey === mtimeKey) {
+    if (cachedSettings !== undefined) {
         return cachedSettings;
     }
 
-    const context = settingsReadContext ?? { cwd: process.cwd(), projectTrusted: false };
-    const manager = SettingsManager.create(context.cwd, getAgentDir(), {
-        projectTrusted: context.projectTrusted,
-    });
     let showModeName = false;
     let useThinkingBorderColors = false;
+    let showThinkingLevelStatus = false;
 
-    const globalSettings = manager.getGlobalSettings() as Record<string, unknown>;
+    const globalSettings = readSettingsObject(getSettingsPath());
     showModeName = applyBooleanSetting(globalSettings, SHOW_MODE_NAME_SETTINGS_KEY, showModeName);
     useThinkingBorderColors = applyBooleanSetting(
         globalSettings,
         USE_THINKING_BORDER_COLORS_SETTINGS_KEY,
         useThinkingBorderColors,
     );
-
-    const projectSettings = manager.getProjectSettings() as Record<string, unknown>;
-    showModeName = applyBooleanSetting(projectSettings, SHOW_MODE_NAME_SETTINGS_KEY, showModeName);
-    useThinkingBorderColors = applyBooleanSetting(
-        projectSettings,
-        USE_THINKING_BORDER_COLORS_SETTINGS_KEY,
-        useThinkingBorderColors,
+    showThinkingLevelStatus = applyBooleanSetting(
+        globalSettings,
+        SHOW_THINKING_LEVEL_STATUS_SETTINGS_KEY,
+        showThinkingLevelStatus,
     );
 
+    const projectSettingsPath = getProjectSettingsPath();
+    if (projectSettingsPath !== undefined) {
+        const projectSettings = readSettingsObject(projectSettingsPath);
+        showModeName = applyBooleanSetting(
+            projectSettings,
+            SHOW_MODE_NAME_SETTINGS_KEY,
+            showModeName,
+        );
+        useThinkingBorderColors = applyBooleanSetting(
+            projectSettings,
+            USE_THINKING_BORDER_COLORS_SETTINGS_KEY,
+            useThinkingBorderColors,
+        );
+        showThinkingLevelStatus = applyBooleanSetting(
+            projectSettings,
+            SHOW_THINKING_LEVEL_STATUS_SETTINGS_KEY,
+            showThinkingLevelStatus,
+        );
+    }
+
     cachedSettings = {
-        mtimeKey,
         showModeName,
         useThinkingBorderColors,
+        showThinkingLevelStatus,
     };
     return cachedSettings;
 }
@@ -306,6 +410,10 @@ export function shouldUseThinkingBorderColors(): boolean {
     return readModeSettings().useThinkingBorderColors;
 }
 
+export function shouldShowThinkingLevelStatus(): boolean {
+    return readModeSettings().showThinkingLevelStatus;
+}
+
 export function setShowModeName(show: boolean): void {
     updateSettingsObject((settings) => {
         settings[SHOW_MODE_NAME_SETTINGS_KEY] = show;
@@ -321,3 +429,11 @@ export function setUseThinkingBorderColors(useThinkingBorderColors: boolean): vo
 
     cachedSettings = undefined;
 }
+
+export function setShowThinkingLevelStatus(showThinkingLevelStatus: boolean): void {
+    updateSettingsObject((settings) => {
+        settings[SHOW_THINKING_LEVEL_STATUS_SETTINGS_KEY] = showThinkingLevelStatus;
+    });
+
+    cachedSettings = undefined;
+}

package/src/status.ts

@@ -0,0 +1,116 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { shouldShowThinkingLevelStatus } from "./settings.ts";
+
+const STATUS_PATCH_MARKER = Symbol.for("zigai.pi-mode.thinking-status-patch");
+const STATUS_PATCH_STATE = Symbol.for("zigai.pi-mode.thinking-status-state");
+const THINKING_LEVEL_STATUS_PREFIX = "Thinking level: ";
+
+type InteractiveModePrototype = {
+    showStatus(message: string): void;
+    [STATUS_PATCH_MARKER]?: true;
+};
+
+type StatusPatchState = {
+    shouldShowThinkingLevelStatus: () => boolean;
+};
+
+type InteractiveModeClass = {
+    prototype: InteractiveModePrototype;
+};
+
+type InteractiveModeModule = {
+    InteractiveMode?: InteractiveModeClass;
+};
+
+type ShowStatus = (this: InteractiveModePrototype, message: string) => void;
+
+type ThinkingLevelStatusPatchOptions = {
+    readonly loadInteractiveModeModule?: () => Promise<InteractiveModeModule | undefined>;
+    readonly shouldShowThinkingLevelStatus?: () => boolean;
+};
+
+function isShowStatus(value: unknown): value is ShowStatus {
+    return typeof value === "function";
+}
+
+function getStatusPatchState(): StatusPatchState {
+    const existing = Reflect.get(globalThis, STATUS_PATCH_STATE);
+    if (typeof existing === "object" && existing !== null) {
+        const reader = Reflect.get(existing, "shouldShowThinkingLevelStatus");
+        if (typeof reader === "function") {
+            return existing as StatusPatchState;
+        }
+    }
+
+    const patchState: StatusPatchState = {
+        shouldShowThinkingLevelStatus: () => true,
+    };
+    Reflect.set(globalThis, STATUS_PATCH_STATE, patchState);
+    return patchState;
+}
+
+function warnStatusPatchUnavailable(error?: unknown): void {
+    let suffix = "";
+    if (error instanceof Error && error.message.length > 0) {
+        suffix = `: ${error.message}`;
+    }
+    console.warn(
+        `[pi-mode] thinking-level status patch unavailable; Pi internals may have changed${suffix}`,
+    );
+}
+
+async function loadInteractiveModeModule(): Promise<InteractiveModeModule | undefined> {
+    try {
+        const codingAgentEntry = fileURLToPath(
+            import.meta.resolve("@earendil-works/pi-coding-agent"),
+        );
+        const distDir = dirname(codingAgentEntry);
+        const interactiveModePath = pathToFileURL(
+            join(distDir, "modes/interactive/interactive-mode.js"),
+        ).href;
+        return (await import(interactiveModePath)) as InteractiveModeModule;
+    } catch (error: unknown) {
+        warnStatusPatchUnavailable(error);
+        return undefined;
+    }
+}
+
+export async function applyThinkingLevelStatusPatch(
+    options: ThinkingLevelStatusPatchOptions = {},
+): Promise<void> {
+    const patchState = getStatusPatchState();
+    patchState.shouldShowThinkingLevelStatus =
+        options.shouldShowThinkingLevelStatus ?? shouldShowThinkingLevelStatus;
+
+    const loadModule = options.loadInteractiveModeModule ?? loadInteractiveModeModule;
+    const module = await loadModule();
+    const prototype = module?.InteractiveMode?.prototype;
+    if (prototype === undefined) return;
+    if (prototype[STATUS_PATCH_MARKER] === true) return;
+    if (typeof prototype.showStatus !== "function") {
+        warnStatusPatchUnavailable(new Error("InteractiveMode.showStatus is not a function"));
+        return;
+    }
+
+    const showStatusDescriptor = Object.getOwnPropertyDescriptor(prototype, "showStatus");
+    const showStatus: unknown = showStatusDescriptor?.value;
+    if (!isShowStatus(showStatus)) {
+        warnStatusPatchUnavailable(new Error("InteractiveMode.showStatus descriptor is invalid"));
+        return;
+    }
+
+    prototype.showStatus = function patchedShowStatus(
+        this: InteractiveModePrototype,
+        message: string,
+    ): void {
+        if (
+            message.startsWith(THINKING_LEVEL_STATUS_PREFIX) &&
+            patchState.shouldShowThinkingLevelStatus() === false
+        ) {
+            return;
+        }
+        showStatus.call(this, message);
+    };
+    prototype[STATUS_PATCH_MARKER] = true;
+}

package/src/storage.ts

@@ -1,4 +1,4 @@
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
 import fs from "node:fs/promises";
 import path from "node:path";
 
@@ -6,12 +6,26 @@ export function getGlobalAgentDir(): string {
     return getAgentDir();
 }
 
+const EXTENSION_ID = "pi-mode";
+const CONFIG_FILE = "config.json";
+const SCHEMA_FILE = "config.schema.json";
+
+const DEFAULT_MODES_CONFIG_FILE = {
+    $schema: `./${SCHEMA_FILE}`,
+    version: 1,
+    currentMode: "default",
+    modeShowName: false,
+    modeUseThinkingBorderColors: false,
+    modeShowThinkingLevelStatus: false,
+    modes: {},
+};
+
 export function getGlobalModesPath(): string {
-    return path.join(getGlobalAgentDir(), "modes.json");
+    return path.join(getGlobalAgentDir(), EXTENSION_ID, CONFIG_FILE);
 }
 
 export function getProjectModesPath(cwd: string): string {
-    return path.join(cwd, ".pi", "modes.json");
+    return path.join(cwd, CONFIG_DIR_NAME, EXTENSION_ID, CONFIG_FILE);
 }
 
 export async function fileExists(filePath: string): Promise<boolean> {
@@ -27,6 +41,71 @@ export async function ensureDirForFile(filePath: string): Promise<void> {
     await fs.mkdir(path.dirname(filePath), { recursive: true });
 }
 
+function getSchemaPath(configPath: string): string {
+    return path.join(path.dirname(configPath), SCHEMA_FILE);
+}
+
+async function writeIfMissing(filePath: string, content: string): Promise<void> {
+    try {
+        await ensureDirForFile(filePath);
+        await fs.writeFile(filePath, content, { encoding: "utf8", flag: "wx" });
+    } catch (error: unknown) {
+        if (error instanceof Error && (error as NodeJS.ErrnoException).code === "EEXIST") return;
+        if (error instanceof Error) throw error;
+        throw new Error(String(error));
+    }
+}
+
+async function refreshSchemaFile(filePath: string, content: string): Promise<void> {
+    let temporaryPath: string | undefined;
+    try {
+        await ensureDirForFile(filePath);
+        try {
+            if ((await fs.readFile(filePath, "utf8")) === content) return;
+        } catch (error: unknown) {
+            if (!(error instanceof Error) || (error as NodeJS.ErrnoException).code !== "ENOENT") {
+                throw error;
+            }
+        }
+
+        const nextTemporaryPath = `${filePath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        await fs.writeFile(nextTemporaryPath, content, { encoding: "utf8", flag: "wx" });
+        temporaryPath = nextTemporaryPath;
+        await fs.rename(temporaryPath, filePath);
+        temporaryPath = undefined;
+    } catch (error: unknown) {
+        if (temporaryPath !== undefined) {
+            try {
+                await fs.unlink(temporaryPath);
+            } catch {
+                // Ignore cleanup failure while reporting the original scaffold failure.
+            }
+        }
+        if (error instanceof Error) throw error;
+        throw new Error(String(error));
+    }
+}
+
+async function readBundledSchema(): Promise<string | undefined> {
+    try {
+        return await fs.readFile(new URL("../config.schema.json", import.meta.url), "utf8");
+    } catch {
+        return undefined;
+    }
+}
+
+export async function scaffoldGlobalModesConfig(): Promise<void> {
+    const globalConfigPath = getGlobalModesPath();
+    const schema = await readBundledSchema();
+    if (schema !== undefined) {
+        await refreshSchemaFile(getSchemaPath(globalConfigPath), schema);
+    }
+    await writeIfMissing(
+        globalConfigPath,
+        `${JSON.stringify(DEFAULT_MODES_CONFIG_FILE, null, 2)}\n`,
+    );
+}
+
 export async function getMtimeMs(filePath: string): Promise<number | null> {
     try {
         const stat = await fs.stat(filePath);