localpi 0.2.0 → 0.3.0

package/dist/src/localpi/model-profile.js

@@ -0,0 +1,98 @@
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { asObject, requiredString } from "../common/json.js";
+import { normalizeBaseUrl } from "../llm/openai.js";
+export async function loadLocalModelProfile(options) {
+    if (options.modelProfileFile === undefined) {
+        return undefined;
+    }
+    const raw = await readFile(expandHome(options.modelProfileFile), "utf8");
+    return parseLocalModelProfile(JSON.parse(raw), options.modelProfileFile);
+}
+export function profileMatchesModel(profile, modelId) {
+    return modelId === profile.model || modelId === profile.id;
+}
+export function profileMatchesBaseUrl(profile, baseUrl) {
+    return (profile.baseUrl === undefined || normalizeBaseUrl(profile.baseUrl) === normalizeBaseUrl(baseUrl));
+}
+function parseLocalModelProfile(value, source) {
+    const root = asObject(value, `model profile ${source}`);
+    const client = optionalObject(root["client"], `model profile ${source} client`);
+    const capabilities = optionalObject(root["capabilities"], `model profile ${source} capabilities`);
+    const contextWindow = client === undefined
+        ? undefined
+        : optionalPositiveInteger(client["context_window"], `model profile ${source} client.context_window`);
+    const maxTokens = client === undefined
+        ? undefined
+        : optionalPositiveInteger(client["max_tokens"], `model profile ${source} client.max_tokens`);
+    const reasoning = capabilities === undefined
+        ? undefined
+        : optionalBoolean(capabilities["reasoning"], `model profile ${source} capabilities.reasoning`);
+    const thinkingFormat = capabilities === undefined
+        ? undefined
+        : optionalThinkingFormat(optionalProfileString(capabilities["thinking_format"], `model profile ${source} capabilities.thinking_format`), `model profile ${source} capabilities.thinking_format`);
+    return withoutUndefined({
+        id: requiredString(root["id"], `model profile ${source} id`),
+        model: requiredString(root["model"], `model profile ${source} model`),
+        baseUrl: optionalProfileString(root["base_url"], `model profile ${source} base_url`),
+        client: client === undefined
+            ? undefined
+            : withoutUndefined({
+                contextWindow,
+                maxTokens
+            }),
+        capabilities: capabilities === undefined
+            ? undefined
+            : withoutUndefined({
+                reasoning,
+                thinkingFormat
+            })
+    });
+}
+function optionalObject(value, context) {
+    return value === undefined ? undefined : asObject(value, context);
+}
+function optionalProfileString(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        throw new Error(`${context} must be a string`);
+    }
+    return value;
+}
+function optionalBoolean(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "boolean") {
+        throw new Error(`${context} must be a boolean`);
+    }
+    return value;
+}
+function optionalPositiveInteger(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw new Error(`${context} must be a positive integer`);
+    }
+    return value;
+}
+function optionalThinkingFormat(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "deepseek" || value === "qwen-chat-template") {
+        return value;
+    }
+    throw new Error(`${context} must be deepseek or qwen-chat-template`);
+}
+function expandHome(value) {
+    const home = os.homedir();
+    return value === "~" || value.startsWith("~/") ? path.join(home, value.slice(2)) : value;
+}
+function withoutUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entryValue]) => entryValue !== undefined));
+}

package/dist/src/localpi/options.js

@@ -18,10 +18,13 @@ export function defaultOptions() {
         provider: process.env["LOCALPI_PROVIDER"],
         customProviderId: envString("LOCALPI_PROVIDER_ID", "local-openai"),
         providersFile: process.env["LOCALPI_PROVIDERS_FILE"],
+        modelProfileFile: process.env["LOCALPI_MODEL_PROFILE"] ?? process.env["LOCALPAGER_AGENT_PROFILE"],
+        modelReasoning: envOptionalBoolean("LOCALPI_MODEL_REASONING", "LOCALPAGER_AGENT_REASONING"),
+        modelThinkingFormat: envOptionalThinkingFormat("LOCALPI_MODEL_THINKING_FORMAT", "LOCALPAGER_AGENT_THINKING_FORMAT"),
         stateDir,
         sessionDir: defaultSessionDir(stateDir),
         piCommand: envString("LOCALPI_PI_CMD", "npx -y @earendil-works/pi-coding-agent@latest"),
-        thinking: parseThinkingLevel(envString("LOCALPI_THINKING", "off")),
+        thinking: parseThinkingLevel(envString("LOCALPI_THINKING", "medium")),
         contextWindow: envOptionalPositiveInteger("LOCALPI_CONTEXT_WINDOW"),
         maxTokens: envPositiveInteger("LOCALPI_MAX_TOKENS", "8192"),
         timeoutMs: envPositiveInteger("LOCALPI_TIMEOUT_MS", "3000"),
@@ -34,6 +37,12 @@ export function defaultOptions() {
         tools: envString("LOCALPI_TOOLS", "read,bash,edit,write,grep,find,ls"),
         approval: envBoolean("LOCALPI_APPROVAL", true),
         tokenStatus: envBoolean("LOCALPI_TOKEN_STATUS", true),
+        demo: envBoolean("LOCALPI_DEMO", false),
+        demoFromCli: false,
+        demoInitialPrompt: process.env["LOCALPI_DEMO_INITIAL_PROMPT"],
+        demoInitialPromptFile: process.env["LOCALPI_DEMO_INITIAL_PROMPT_FILE"],
+        demoFollowupPrompt: process.env["LOCALPI_DEMO_FOLLOWUP_PROMPT"],
+        demoFollowupPromptFile: process.env["LOCALPI_DEMO_FOLLOWUP_PROMPT_FILE"],
         status: false,
         stop: false,
         list: false,
@@ -43,6 +52,7 @@ export function defaultOptions() {
 export function parseLocalpiArgs(args) {
     let options = defaultOptions();
     const forwardedArgs = [];
+    const demoPromptFlags = demoPromptFlagTracker();
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === undefined) {
@@ -55,6 +65,7 @@ export function parseLocalpiArgs(args) {
         if (arg === "-h" || arg === "--help") {
             return { ...options, forwardedArgs: ["--help"] };
         }
+        trackDemoPromptFlag(demoPromptFlags, arg);
         const parsed = parseLocalpiFlag(options, args, index);
         if (parsed !== undefined) {
             options = parsed.options;
@@ -63,7 +74,7 @@ export function parseLocalpiArgs(args) {
         }
         forwardedArgs.push(arg);
     }
-    return { ...options, forwardedArgs };
+    return normalizeDemoPromptPrecedence({ ...options, forwardedArgs }, demoPromptFlags);
 }
 export function usage() {
     return `${[
@@ -89,8 +100,21 @@ export function usage() {
         "  --chat-template <path>   llama.cpp chat template file",
         "  --tools <list>           Pi tools allow list",
         "  --providers-file <path>  localpi provider registry JSON",
+        "  --model-profile <path>   local model capability profile JSON",
+        "  --model-reasoning <bool> override generated Pi reasoning capability",
+        "  --model-thinking-format <format>",
+        "                          override generated Pi thinking format",
         "  --no-approval           do not ask before tool calls",
         "  --no-token-status       do not install token status extension",
+        "  --demo                  endlessly run Pi prompts for demo mode",
+        "  --demo-initial-prompt <text>",
+        "                          first demo prompt",
+        "  --demo-followup-prompt <text>",
+        "                          repeated demo prompt after the first run",
+        "  --demo-initial-prompt-file <path>",
+        "                          UTF-8 file for the first demo prompt",
+        "  --demo-followup-prompt-file <path>",
+        "                          UTF-8 file for repeated demo prompts",
         "  --status                print runtime status and exit",
         "  --stop                  stop the localpi-owned llama-server",
         "  --list                  list model aliases",
@@ -132,7 +156,8 @@ const booleanFlagUpdaters = {
     "--stop": (options) => ({ ...options, stop: true }),
     "--list": (options) => ({ ...options, list: true }),
     "--no-approval": (options) => ({ ...options, approval: false }),
-    "--no-token-status": (options) => ({ ...options, tokenStatus: false })
+    "--no-token-status": (options) => ({ ...options, tokenStatus: false }),
+    "--demo": (options) => ({ ...options, demo: true, demoFromCli: true })
 };
 const valueFlagUpdaters = {
     "--runtime": (options, value) => ({ ...options, runtime: parseRuntime(value) }),
@@ -141,6 +166,12 @@ const valueFlagUpdaters = {
     "--provider": (options, value) => ({ ...options, provider: value }),
     "--provider-id": (options, value) => ({ ...options, customProviderId: value }),
     "--providers-file": (options, value) => ({ ...options, providersFile: value }),
+    "--model-profile": (options, value) => ({ ...options, modelProfileFile: value }),
+    "--model-reasoning": (options, value) => ({ ...options, modelReasoning: parseBoolean(value) }),
+    "--model-thinking-format": (options, value) => ({
+        ...options,
+        modelThinkingFormat: parseModelThinkingFormat(value)
+    }),
     "--state-dir": (options, value) => ({ ...options, stateDir: value }),
     "--session-dir": (options, value) => ({ ...options, sessionDir: value }),
     "--pi-command": (options, value) => ({ ...options, piCommand: value }),
@@ -159,7 +190,17 @@ const valueFlagUpdaters = {
     "--gpu-layers": (options, value) => ({ ...options, gpuLayers: parseNonNegativeInteger(value) }),
     "--parallel": (options, value) => ({ ...options, parallel: parsePositiveInteger(value) }),
     "--chat-template": (options, value) => ({ ...options, chatTemplate: value }),
-    "--tools": (options, value) => ({ ...options, tools: value })
+    "--tools": (options, value) => ({ ...options, tools: value }),
+    "--demo-initial-prompt": (options, value) => ({ ...options, demoInitialPrompt: value }),
+    "--demo-followup-prompt": (options, value) => ({ ...options, demoFollowupPrompt: value }),
+    "--demo-initial-prompt-file": (options, value) => ({
+        ...options,
+        demoInitialPromptFile: value
+    }),
+    "--demo-followup-prompt-file": (options, value) => ({
+        ...options,
+        demoFollowupPromptFile: value
+    })
 };
 function parseValueFlag(options, args, index, flag) {
     const updater = valueFlagUpdaters[flag];
@@ -168,6 +209,37 @@ function parseValueFlag(options, args, index, flag) {
     }
     return { options: updater(options, requiredValue(args, index + 1, flag)), advance: 1 };
 }
+function demoPromptFlagTracker() {
+    return {
+        initialText: false,
+        initialFile: false,
+        followupText: false,
+        followupFile: false
+    };
+}
+function trackDemoPromptFlag(tracker, arg) {
+    switch (arg) {
+        case "--demo-initial-prompt":
+            tracker.initialText = true;
+            return;
+        case "--demo-initial-prompt-file":
+            tracker.initialFile = true;
+            return;
+        case "--demo-followup-prompt":
+            tracker.followupText = true;
+            return;
+        case "--demo-followup-prompt-file":
+            tracker.followupFile = true;
+            return;
+    }
+}
+function normalizeDemoPromptPrecedence(options, tracker) {
+    return {
+        ...options,
+        demoInitialPromptFile: tracker.initialText && !tracker.initialFile ? undefined : options.demoInitialPromptFile,
+        demoFollowupPromptFile: tracker.followupText && !tracker.followupFile ? undefined : options.demoFollowupPromptFile
+    };
+}
 function parseRuntime(value) {
     if (value === "auto" ||
         value === "llama-server" ||
@@ -186,6 +258,12 @@ export function parseThinkingLevel(value) {
     }
     throw new Error(`unknown thinking level ${value}; expected off, minimal, low, medium, high, or xhigh`);
 }
+function parseModelThinkingFormat(value) {
+    if (value === "deepseek" || value === "qwen-chat-template") {
+        return value;
+    }
+    throw new Error(`unknown model thinking format ${value}; expected deepseek or qwen-chat-template`);
+}
 function envString(name, fallback) {
     return process.env[name] ?? fallback;
 }
@@ -203,11 +281,22 @@ function envOptionalPositiveInteger(name) {
     const value = process.env[name];
     return value === undefined ? undefined : parsePositiveInteger(value);
 }
+function envOptionalBoolean(primaryName, fallbackName) {
+    const [name, value] = envFirst([primaryName, fallbackName]);
+    return value === undefined ? undefined : parseBoolean(value, name);
+}
+function envOptionalThinkingFormat(primaryName, fallbackName) {
+    const [, value] = envFirst([primaryName, fallbackName]);
+    return value === undefined ? undefined : parseModelThinkingFormat(value);
+}
 function envBoolean(name, fallback) {
     const value = process.env[name];
     if (value === undefined) {
         return fallback;
     }
+    return parseBoolean(value, name);
+}
+function parseBoolean(value, name = "value") {
     if (["1", "true", "yes", "on"].includes(value.toLowerCase())) {
         return true;
     }
@@ -216,6 +305,15 @@ function envBoolean(name, fallback) {
     }
     throw new Error(`${name} must be boolean-like, got ${value}`);
 }
+function envFirst(names) {
+    for (const name of names) {
+        const value = process.env[name];
+        if (value !== undefined) {
+            return [name, value];
+        }
+    }
+    return [names[0] ?? "", undefined];
+}
 function defaultSessionDir(stateDir) {
     return envString("LOCALPI_SESSION_DIR", envString("PI_CODING_AGENT_SESSION_DIR", path.join(stateDir, "sessions")));
 }

package/dist/src/localpi/runtime-connection.js

@@ -1,4 +1,4 @@
-import { formatCatalogWarning, managedModelSupportsReasoning } from "./catalog.js";
+import { formatCatalogWarning, managedCapabilityConfig } from "./catalog.js";
 export function connectionStatus(connection) {
     return ([
         `runtime: ${connection.runtime}`,
@@ -39,9 +39,7 @@ export function catalogModelFromModelInfo(providerId, providerName, runtime, bas
         aliases: [],
         displayName: `${providerName} / ${model.id}`,
         maxTokens: options.maxTokens,
-        ...(runtime === "managed-llama-server"
-            ? { reasoning: managedModelSupportsReasoning(model.id) }
-            : {}),
+        ...(runtime === "managed-llama-server" ? managedCapabilityConfig(model.id, options) : {}),
         capabilities: ["text"],
         availability: "loaded",
         ...optionalContextWindow(contextWindow ?? model.contextWindow)

package/dist/src/localpi/settings-state.js

@@ -0,0 +1,37 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { asObject, optionalString } from "../common/json.js";
+import { parseThinkingLevel } from "./options.js";
+export function settingsStatePath(options) {
+    return path.join(options.stateDir, "settings.json");
+}
+export async function applyRememberedSettings(options, explicit) {
+    const settings = await readLocalpiSettings(options);
+    return {
+        ...options,
+        thinking: explicit.thinking || settings.thinking === undefined ? options.thinking : settings.thinking
+    };
+}
+async function readLocalpiSettings(options) {
+    let raw;
+    try {
+        raw = await readFile(settingsStatePath(options), "utf8");
+    }
+    catch (error) {
+        if (isMissingFile(error)) {
+            return {};
+        }
+        throw error;
+    }
+    try {
+        const root = asObject(JSON.parse(raw), "localpi settings");
+        const thinking = optionalString(root["thinking"]);
+        return thinking === undefined ? {} : { thinking: parseThinkingLevel(thinking) };
+    }
+    catch {
+        return {};
+    }
+}
+function isMissingFile(error) {
+    return (error instanceof Error && "code" in error && error.code === "ENOENT");
+}

package/dist/src/pi/demo.js

@@ -0,0 +1,12 @@
+import { readFile } from "node:fs/promises";
+export const defaultDemoInitialPrompt = "You are narrating a never-ending sci-fi adventure. Continue in short paragraphs. Whenever the user sends a message, treat it as a live director note and incorporate it immediately. Never end the story.";
+export const defaultDemoFollowupPrompt = "Continue. Try to write as long as possible.";
+export async function resolveDemoPrompts(options) {
+    return {
+        initial: await resolvePrompt(options.demoInitialPrompt, options.demoInitialPromptFile, defaultDemoInitialPrompt),
+        followup: await resolvePrompt(options.demoFollowupPrompt, options.demoFollowupPromptFile, defaultDemoFollowupPrompt)
+    };
+}
+async function resolvePrompt(text, file, fallback) {
+    return file === undefined ? (text ?? fallback) : await readFile(file, "utf8");
+}

package/dist/src/pi/extensions.js

@@ -1,5 +1,7 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { settingsStatePath } from "../localpi/settings-state.js";
+import { resolveDemoPrompts } from "./demo.js";
 export async function writeDefaultExtensions(options, extensionOptions = {}) {
     const extensionDir = path.join(options.stateDir, "pi-extensions");
     await mkdir(extensionDir, { recursive: true });
@@ -7,7 +9,10 @@ export async function writeDefaultExtensions(options, extensionOptions = {}) {
     if (extensionOptions.startupModelSelector !== undefined) {
         paths.push(await writeExtension(extensionDir, "startup-model-selector.ts", startupModelSelectorExtensionSource(extensionOptions.startupModelSelector)));
     }
-    paths.push(await writeExtension(extensionDir, "thinking-control.ts", thinkingControlExtensionSource()));
+    if (options.demo) {
+        paths.push(await writeExtension(extensionDir, "demo-mode.ts", demoModeExtensionSource(await resolveDemoPrompts(options))));
+    }
+    paths.push(await writeExtension(extensionDir, "thinking-control.ts", thinkingControlExtensionSource(settingsStatePath(options))));
     if (options.approval) {
         paths.push(await writeExtension(extensionDir, "tool-approval.ts", approvalExtensionSource()));
     }
@@ -24,6 +29,58 @@ async function writeExtension(extensionDir, name, source) {
     await writeFile(extensionPath, source, "utf8");
     return extensionPath;
 }
+function demoModeExtensionSource(prompts) {
+    const initialPromptSource = JSON.stringify(prompts.initial);
+    const followupPromptSource = JSON.stringify(prompts.followup);
+    return `import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const initialPrompt = ${initialPromptSource};
+const followupPrompt = ${followupPromptSource};
+
+export default function localpiDemoMode(pi: ExtensionAPI): void {
+  let started = false;
+  let stopped = false;
+
+  pi.on("session_start", (event, ctx) => {
+    if (started || stopped || event.reason !== "startup" || ctx.mode !== "tui") {
+      return;
+    }
+    started = true;
+    queueMicrotask(() => {
+      if (!stopped) {
+        pi.sendUserMessage(initialPrompt);
+      }
+    });
+  });
+
+  pi.on("turn_end", (event, ctx) => {
+    if (!started || stopped || ctx.mode !== "tui") {
+      return;
+    }
+    if (event.message.role !== "assistant") {
+      return;
+    }
+    switch (event.message.stopReason) {
+      case "aborted":
+      case "error":
+        stopped = true;
+        return;
+      case "toolUse":
+        return;
+    }
+    queueMicrotask(() => {
+      if (!stopped) {
+        pi.sendUserMessage(followupPrompt, { deliverAs: "followUp" });
+      }
+    });
+  });
+
+  pi.on("session_shutdown", () => {
+    stopped = true;
+  });
+}
+`;
+}
 function startupModelSelectorExtensionSource(options) {
     const startupModelsSource = JSON.stringify(options.models);
     return `import type { ExtensionAPI, SettingsManager } from "@earendil-works/pi-coding-agent";
@@ -290,12 +347,16 @@ function textUpdateFromUnknown(value: unknown): TextUpdate {
 }
 `;
 }
-function thinkingControlExtensionSource() {
-    return `import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+function thinkingControlExtensionSource(settingsPath) {
+    const settingsPathSource = JSON.stringify(settingsPath);
+    return `import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
 
 const levels: readonly ThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh"];
+const settingsPath = ${settingsPathSource};
 
 export default function localpiThinkingControl(pi: ExtensionAPI): void {
   pi.registerCommand("thinking", {
@@ -313,6 +374,7 @@ export default function localpiThinkingControl(pi: ExtensionAPI): void {
       }
       pi.setThinkingLevel(level);
       const actual = pi.getThinkingLevel();
+      await persistThinking(actual);
       ctx.ui.notify(
         actual === level ? \`thinking: \${actual}\` : \`thinking: \${actual} (clamped from \${level})\`,
         actual === level ? "info" : "warning"
@@ -320,15 +382,33 @@ export default function localpiThinkingControl(pi: ExtensionAPI): void {
     }
   });
 
-  pi.on("thinking_level_select", (event, ctx) => {
+  pi.on("thinking_level_select", async (event, ctx) => {
+    await persistThinking(event.level);
     ctx.ui.setStatus("localpi-thinking", \`thinking: \${event.level}\`);
   });
 
-  pi.on("session_shutdown", (_event, ctx) => {
+  pi.on("session_shutdown", async (_event, ctx) => {
+    await persistThinking(pi.getThinkingLevel());
     ctx.ui.setStatus("localpi-thinking", undefined);
   });
 }
 
+async function persistThinking(level: ThinkingLevel): Promise<void> {
+  const settings = await readSettings();
+  settings.thinking = level;
+  await mkdir(dirname(settingsPath), { recursive: true });
+  await writeFile(settingsPath, \`\${JSON.stringify(settings, null, 2)}\\n\`, "utf8");
+}
+
+async function readSettings(): Promise<Record<string, unknown>> {
+  try {
+    const value = JSON.parse(await readFile(settingsPath, "utf8"));
+    return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
+  } catch {
+    return {};
+  }
+}
+
 async function promptThinkingLevel(
   current: ThinkingLevel,
   ctx: { readonly ui: { select(title: string, options: string[]): Promise<string | undefined> } }

package/docs/2026-06-16-startup-model-and-thinking-control-plan.md

@@ -24,7 +24,7 @@ Startup selection is for models only. There is no startup thinking picker.
 - Explicit `--runtime` values scope discovery but do not disable the startup selector by themselves.
 - Non-interactive runs never show a picker.
 - Pi receives the launch-time model catalog so `/model` can switch across discovered providers and models.
-- Thinking starts as `off` unless `--thinking` or `LOCALPI_THINKING` sets another startup level.
+- Thinking starts from `--thinking`, `LOCALPI_THINKING`, the last saved Pi thinking level, or `medium`.
 - In-session thinking changes happen through `/thinking` inside Pi.
 
 ## Provider Coverage
@@ -86,9 +86,9 @@ Thinking is not selected at startup through a picker.
 
 Startup defaults:
 
-- `localpi` starts with thinking `off`.
-- `LOCALPI_THINKING=<level>` changes the startup default.
-- `localpi --thinking <level>` overrides the startup default.
+- `localpi` starts with the last saved thinking level, or `medium` if none is saved.
+- `LOCALPI_THINKING=<level>` overrides the saved startup default.
+- `localpi --thinking <level>` overrides the saved startup default.
 - The chosen startup value is passed to Pi as `--thinking <level>` and written to `settings.json.defaultThinkingLevel`.
 
 In-session control:
@@ -97,6 +97,7 @@ In-session control:
 - `/thinking` opens Pi's selector UI.
 - `/thinking high` sets the level directly.
 - The extension calls Pi's thinking API, so Pi owns runtime mutation.
+- The extension saves the actual Pi thinking level to localpi state for the next launch.
 
 Managed `llama-server` caveat:
 
@@ -114,6 +115,7 @@ Managed `llama-server` caveat:
 - [x] Add `/thinking` as a Pi extension command.
 - [x] Keep startup thinking non-interactive.
 - [x] Keep `--thinking` and `LOCALPI_THINKING` as automation-safe startup controls.
+- [x] Remember the last Pi thinking level for future localpi launches.
 - [ ] Manually verify model picker behavior in an interactive terminal with multiple loaded providers.
 - [ ] Manually verify Pi `/model` can switch among generated catalog entries.
 - [ ] Manually verify Pi `/thinking` picker and direct `/thinking <level>` command.