localpi 0.2.0 → 0.4.0

package/dist/src/pi/extension-sources/thinking-control.js

@@ -0,0 +1,79 @@
+export 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", {
+    description: "Set localpi thinking level",
+    getArgumentCompletions: (prefix) => {
+      const trimmed = prefix.trim().toLowerCase();
+      const matches = levels.filter((level) => level.startsWith(trimmed));
+      return matches.length === 0 ? null : matches.map((level) => ({ value: level, label: level }));
+    },
+    handler: async (args, ctx) => {
+      const requested = parseThinkingLevel(args);
+      const level = requested ?? (await promptThinkingLevel(pi.getThinkingLevel(), ctx));
+      if (level === undefined) {
+        return;
+      }
+      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"
+      );
+    }
+  });
+
+  pi.on("thinking_level_select", async (event, ctx) => {
+    await persistThinking(event.level);
+    ctx.ui.setStatus("localpi-thinking", \`thinking: \${event.level}\`);
+  });
+
+  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> } }
+): Promise<ThinkingLevel | undefined> {
+  const selected = await ctx.ui.select(
+    "Thinking level",
+    levels.map((level) => (level === current ? \`\${level} (current)\` : level))
+  );
+  return selected === undefined ? undefined : parseThinkingLevel(selected);
+}
+
+function parseThinkingLevel(value: string): ThinkingLevel | undefined {
+  const normalized = value.trim().split(/\\s+/u)[0]?.toLowerCase();
+  return levels.find((level) => level === normalized);
+}
+`;
+}

package/dist/src/pi/extension-sources/token-status.js

@@ -0,0 +1,133 @@
+export function tokenStatusExtensionSource() {
+    return `import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+type Usage = {
+  input?: number;
+  output?: number;
+  cacheRead?: number;
+  cacheWrite?: number;
+  totalTokens?: number;
+};
+
+type TurnState = {
+  startedAt: number;
+  outputText: string;
+  estimatedOutputTokens: number;
+  lastStatusAt: number;
+};
+
+export default function localpiTokenStatus(pi: ExtensionAPI): void {
+  let currentTurn: TurnState | undefined;
+
+  pi.on("turn_start", () => {
+    currentTurn = {
+      startedAt: Date.now(),
+      outputText: "",
+      estimatedOutputTokens: 0,
+      lastStatusAt: 0
+    };
+  });
+
+  pi.on("message_update", (event, ctx) => {
+    const state = currentTurn;
+    if (!ctx.hasUI || state === undefined) {
+      return;
+    }
+    const update = textUpdateFromUnknown(event.assistantMessageEvent ?? event.message ?? event);
+    if (update.kind === "delta") {
+      state.outputText += update.text;
+    } else if (update.text.length > state.outputText.length) {
+      state.outputText = update.text;
+    }
+    state.estimatedOutputTokens = Math.ceil(state.outputText.length / 4);
+    if (Date.now() - state.lastStatusAt < 250) {
+      return;
+    }
+    state.lastStatusAt = Date.now();
+    ctx.ui.setStatus("localpi-perf", ctx.ui.theme.fg("dim", statusText(state)));
+  });
+
+  pi.on("turn_end", (event, ctx) => {
+    const state = currentTurn ?? {
+      startedAt: Date.now(),
+      outputText: "",
+      estimatedOutputTokens: 0,
+      lastStatusAt: 0
+    };
+    currentTurn = undefined;
+
+    if (!ctx.hasUI || event.message.role !== "assistant") {
+      return;
+    }
+
+    const usage = event.message.usage as Usage | undefined;
+    const output = usage?.output ?? state.estimatedOutputTokens;
+    const input = usage?.input ?? 0;
+    const cacheRead = usage?.cacheRead ?? 0;
+    const cacheWrite = usage?.cacheWrite ?? 0;
+    const elapsedSeconds = elapsed(state);
+    const context = ctx.getContextUsage();
+    const contextText =
+      context && context.percent !== null
+        ? \`ctx \${Math.round(context.percent)}%/\${Math.round(context.contextWindow / 1000)}k\`
+        : "ctx ?";
+
+    ctx.ui.setStatus(
+      "localpi-perf",
+      ctx.ui.theme.fg(
+        "dim",
+        [
+          \`\${(output / elapsedSeconds).toFixed(1)} tok/s\`,
+          \`out \${output}\`,
+          \`in \${input}\`,
+          cacheRead > 0 ? \`cache \${cacheRead}\` : undefined,
+          cacheWrite > 0 ? \`cw \${cacheWrite}\` : undefined,
+          \`\${elapsedSeconds.toFixed(1)}s\`,
+          contextText
+        ]
+          .filter(Boolean)
+          .join(" | ")
+      )
+    );
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => {
+    if (ctx.hasUI) {
+      ctx.ui.setStatus("localpi-perf", "");
+    }
+  });
+}
+
+function statusText(state: TurnState): string {
+  const elapsedSeconds = elapsed(state);
+  return \`\${(state.estimatedOutputTokens / elapsedSeconds).toFixed(1)} tok/s | out ~\${state.estimatedOutputTokens} | \${elapsedSeconds.toFixed(1)}s\`;
+}
+
+function elapsed(state: TurnState): number {
+  return Math.max((Date.now() - state.startedAt) / 1000, 0.001);
+}
+
+type TextUpdate = {
+  kind: "delta" | "snapshot";
+  text: string;
+};
+
+function textUpdateFromUnknown(value: unknown): TextUpdate {
+  if (typeof value === "string") {
+    return { kind: "snapshot", text: value };
+  }
+  if (value && typeof value === "object") {
+    const object = value as Record<string, unknown>;
+    const delta = object["delta"];
+    const text = object["text"] ?? object["content"];
+    if (typeof delta === "string") {
+      return { kind: "delta", text: delta };
+    }
+    if (typeof text === "string") {
+      return { kind: "snapshot", text };
+    }
+  }
+  return { kind: "snapshot", text: "" };
+}
+`;
+}

package/dist/src/pi/extension-sources/tool-approval.js

@@ -0,0 +1,45 @@
+export function approvalExtensionSource() {
+    return `import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export default function localpiToolApproval(pi: ExtensionAPI): void {
+  pi.on("before_agent_start", (event) => ({
+    systemPrompt:
+      event.systemPrompt +
+      "\\n\\nTool approval rule: if any tool result says the tool was blocked, denied, or requires approval, the tool did not run. Do not claim blocked tools ran."
+  }));
+
+  pi.on("tool_call", async (event, ctx) => {
+    const input = formatInput(event.input);
+
+    if (!ctx.hasUI) {
+      return {
+        block: true,
+        reason: \`Tool call "\${event.toolName}" was blocked and did not run because interactive approval is required.\`
+      };
+    }
+
+    const ok = await ctx.ui.confirm(\`Allow tool call: \${event.toolName}?\`, input);
+    if (!ok) {
+      return { block: true, reason: "Tool call was blocked by the user and did not run." };
+    }
+
+    return undefined;
+  });
+}
+
+function formatInput(input: unknown): string {
+  let text: string;
+  try {
+    text = JSON.stringify(input, null, 2);
+  } catch {
+    text = String(input);
+  }
+
+  const maxLength = 4000;
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return \`\${text.slice(0, maxLength)}\\n... truncated ...\`;
+}
+`;
+}

package/dist/src/pi/extensions.js

@@ -1,5 +1,12 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { localpiSettingsPath } from "../localpi/settings-state.js";
+import { resolveDemoPrompts } from "./demo.js";
+import { demoModeExtensionSource } from "./extension-sources/demo-mode.js";
+import { startupModelSelectorExtensionSource } from "./extension-sources/startup-model-selector.js";
+import { thinkingControlExtensionSource } from "./extension-sources/thinking-control.js";
+import { tokenStatusExtensionSource } from "./extension-sources/token-status.js";
+import { approvalExtensionSource } from "./extension-sources/tool-approval.js";
 export async function writeDefaultExtensions(options, extensionOptions = {}) {
     const extensionDir = path.join(options.stateDir, "pi-extensions");
     await mkdir(extensionDir, { recursive: true });
@@ -7,7 +14,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(localpiSettingsPath(options))));
     if (options.approval) {
         paths.push(await writeExtension(extensionDir, "tool-approval.ts", approvalExtensionSource()));
     }
@@ -24,84 +34,6 @@ async function writeExtension(extensionDir, name, source) {
     await writeFile(extensionPath, source, "utf8");
     return extensionPath;
 }
-function startupModelSelectorExtensionSource(options) {
-    const startupModelsSource = JSON.stringify(options.models);
-    return `import type { ExtensionAPI, SettingsManager } from "@earendil-works/pi-coding-agent";
-import { ModelSelectorComponent } from "@earendil-works/pi-coding-agent";
-
-type SelectedModel = Parameters<ExtensionAPI["setModel"]>[0];
-const startupModels = ${startupModelsSource} as const;
-const startupModelKeys = new Set(startupModels.map((model) => modelKey(model)));
-
-export default function localpiStartupModelSelector(pi: ExtensionAPI): void {
-  let opened = false;
-
-  pi.on("session_start", async (event, ctx) => {
-    if (opened || event.reason !== "startup" || ctx.mode !== "tui") {
-      return;
-    }
-
-    const selectableModels = startupAvailableModels(ctx.modelRegistry);
-    if (selectableModels.length <= 1) {
-      return;
-    }
-    const scopedModels = selectableModels.map((model) => ({ model }));
-
-    opened = true;
-    const selected = await ctx.ui.custom<SelectedModel | undefined>((tui, _theme, _keybindings, done) => {
-      const settings = {
-        setDefaultModelAndProvider: () => {}
-      } as unknown as SettingsManager;
-      return new ModelSelectorComponent(
-        tui,
-        ctx.model,
-        settings,
-        startupModelRegistry(ctx.modelRegistry) as typeof ctx.modelRegistry,
-        scopedModels,
-        (model) => done(model),
-        () => done(undefined)
-      );
-    });
-
-    if (selected === undefined) {
-      return;
-    }
-
-    const ok = await pi.setModel(selected);
-    if (!ok) {
-      ctx.ui.notify(\`No API key for \${selected.provider}/\${selected.id}\`, "error");
-    }
-  });
-}
-
-function startupAvailableModels(registry: {
-  getAvailable(): SelectedModel[];
-}): SelectedModel[] {
-  return registry.getAvailable().filter((model) => startupModelKeys.has(modelKey(model)));
-}
-
-function startupModelRegistry(registry: {
-  refresh(): void;
-  getError(): string | undefined;
-  getAvailable(): SelectedModel[];
-  find(provider: string, modelId: string): SelectedModel | undefined;
-}): typeof registry {
-  return {
-    refresh: () => registry.refresh(),
-    getError: () => registry.getError(),
-    getAvailable: () => startupAvailableModels(registry),
-    find: (provider, modelId) => {
-      const model = registry.find(provider, modelId);
-      return model !== undefined && startupModelKeys.has(modelKey(model)) ? model : undefined;
-    }
-  };
-}
-
-function modelKey(model: { readonly provider: string; readonly id: string }): string {
-  return \`\${model.provider}\\u0000\${model.id}\`;
-}
-`;
-}
 function localpiSystemPrompt(approval) {
     return [
         "You are running through localpi, a local Pi launcher for local models.",
@@ -112,237 +44,3 @@ function localpiSystemPrompt(approval) {
         "Prefer answering directly when tools are not needed."
     ].join("\n");
 }
-function approvalExtensionSource() {
-    return `import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-
-export default function localpiToolApproval(pi: ExtensionAPI): void {
-  pi.on("before_agent_start", (event) => ({
-    systemPrompt:
-      event.systemPrompt +
-      "\\n\\nTool approval rule: if any tool result says the tool was blocked, denied, or requires approval, the tool did not run. Do not claim blocked tools ran."
-  }));
-
-  pi.on("tool_call", async (event, ctx) => {
-    const input = formatInput(event.input);
-
-    if (!ctx.hasUI) {
-      return {
-        block: true,
-        reason: \`Tool call "\${event.toolName}" was blocked and did not run because interactive approval is required.\`
-      };
-    }
-
-    const ok = await ctx.ui.confirm(\`Allow tool call: \${event.toolName}?\`, input);
-    if (!ok) {
-      return { block: true, reason: "Tool call was blocked by the user and did not run." };
-    }
-
-    return undefined;
-  });
-}
-
-function formatInput(input: unknown): string {
-  let text: string;
-  try {
-    text = JSON.stringify(input, null, 2);
-  } catch {
-    text = String(input);
-  }
-
-  const maxLength = 4000;
-  if (text.length <= maxLength) {
-    return text;
-  }
-  return \`\${text.slice(0, maxLength)}\\n... truncated ...\`;
-}
-`;
-}
-function tokenStatusExtensionSource() {
-    return `import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-
-type Usage = {
-  input?: number;
-  output?: number;
-  cacheRead?: number;
-  cacheWrite?: number;
-  totalTokens?: number;
-};
-
-type TurnState = {
-  startedAt: number;
-  outputText: string;
-  estimatedOutputTokens: number;
-  lastStatusAt: number;
-};
-
-export default function localpiTokenStatus(pi: ExtensionAPI): void {
-  let currentTurn: TurnState | undefined;
-
-  pi.on("turn_start", () => {
-    currentTurn = {
-      startedAt: Date.now(),
-      outputText: "",
-      estimatedOutputTokens: 0,
-      lastStatusAt: 0
-    };
-  });
-
-  pi.on("message_update", (event, ctx) => {
-    const state = currentTurn;
-    if (!ctx.hasUI || state === undefined) {
-      return;
-    }
-    const update = textUpdateFromUnknown(event.assistantMessageEvent ?? event.message ?? event);
-    if (update.kind === "delta") {
-      state.outputText += update.text;
-    } else if (update.text.length > state.outputText.length) {
-      state.outputText = update.text;
-    }
-    state.estimatedOutputTokens = Math.ceil(state.outputText.length / 4);
-    if (Date.now() - state.lastStatusAt < 250) {
-      return;
-    }
-    state.lastStatusAt = Date.now();
-    ctx.ui.setStatus("localpi-perf", ctx.ui.theme.fg("dim", statusText(state)));
-  });
-
-  pi.on("turn_end", (event, ctx) => {
-    const state = currentTurn ?? {
-      startedAt: Date.now(),
-      outputText: "",
-      estimatedOutputTokens: 0,
-      lastStatusAt: 0
-    };
-    currentTurn = undefined;
-
-    if (!ctx.hasUI || event.message.role !== "assistant") {
-      return;
-    }
-
-    const usage = event.message.usage as Usage | undefined;
-    const output = usage?.output ?? state.estimatedOutputTokens;
-    const input = usage?.input ?? 0;
-    const cacheRead = usage?.cacheRead ?? 0;
-    const cacheWrite = usage?.cacheWrite ?? 0;
-    const elapsedSeconds = elapsed(state);
-    const context = ctx.getContextUsage();
-    const contextText =
-      context && context.percent !== null
-        ? \`ctx \${Math.round(context.percent)}%/\${Math.round(context.contextWindow / 1000)}k\`
-        : "ctx ?";
-
-    ctx.ui.setStatus(
-      "localpi-perf",
-      ctx.ui.theme.fg(
-        "dim",
-        [
-          \`\${(output / elapsedSeconds).toFixed(1)} tok/s\`,
-          \`out \${output}\`,
-          \`in \${input}\`,
-          cacheRead > 0 ? \`cache \${cacheRead}\` : undefined,
-          cacheWrite > 0 ? \`cw \${cacheWrite}\` : undefined,
-          \`\${elapsedSeconds.toFixed(1)}s\`,
-          contextText
-        ]
-          .filter(Boolean)
-          .join(" | ")
-      )
-    );
-  });
-
-  pi.on("session_shutdown", (_event, ctx) => {
-    if (ctx.hasUI) {
-      ctx.ui.setStatus("localpi-perf", "");
-    }
-  });
-}
-
-function statusText(state: TurnState): string {
-  const elapsedSeconds = elapsed(state);
-  return \`\${(state.estimatedOutputTokens / elapsedSeconds).toFixed(1)} tok/s | out ~\${state.estimatedOutputTokens} | \${elapsedSeconds.toFixed(1)}s\`;
-}
-
-function elapsed(state: TurnState): number {
-  return Math.max((Date.now() - state.startedAt) / 1000, 0.001);
-}
-
-type TextUpdate = {
-  kind: "delta" | "snapshot";
-  text: string;
-};
-
-function textUpdateFromUnknown(value: unknown): TextUpdate {
-  if (typeof value === "string") {
-    return { kind: "snapshot", text: value };
-  }
-  if (value && typeof value === "object") {
-    const object = value as Record<string, unknown>;
-    const delta = object["delta"];
-    const text = object["text"] ?? object["content"];
-    if (typeof delta === "string") {
-      return { kind: "delta", text: delta };
-    }
-    if (typeof text === "string") {
-      return { kind: "snapshot", text };
-    }
-  }
-  return { kind: "snapshot", text: "" };
-}
-`;
-}
-function thinkingControlExtensionSource() {
-    return `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"];
-
-export default function localpiThinkingControl(pi: ExtensionAPI): void {
-  pi.registerCommand("thinking", {
-    description: "Set localpi thinking level",
-    getArgumentCompletions: (prefix) => {
-      const trimmed = prefix.trim().toLowerCase();
-      const matches = levels.filter((level) => level.startsWith(trimmed));
-      return matches.length === 0 ? null : matches.map((level) => ({ value: level, label: level }));
-    },
-    handler: async (args, ctx) => {
-      const requested = parseThinkingLevel(args);
-      const level = requested ?? (await promptThinkingLevel(pi.getThinkingLevel(), ctx));
-      if (level === undefined) {
-        return;
-      }
-      pi.setThinkingLevel(level);
-      const actual = pi.getThinkingLevel();
-      ctx.ui.notify(
-        actual === level ? \`thinking: \${actual}\` : \`thinking: \${actual} (clamped from \${level})\`,
-        actual === level ? "info" : "warning"
-      );
-    }
-  });
-
-  pi.on("thinking_level_select", (event, ctx) => {
-    ctx.ui.setStatus("localpi-thinking", \`thinking: \${event.level}\`);
-  });
-
-  pi.on("session_shutdown", (_event, ctx) => {
-    ctx.ui.setStatus("localpi-thinking", undefined);
-  });
-}
-
-async function promptThinkingLevel(
-  current: ThinkingLevel,
-  ctx: { readonly ui: { select(title: string, options: string[]): Promise<string | undefined> } }
-): Promise<ThinkingLevel | undefined> {
-  const selected = await ctx.ui.select(
-    "Thinking level",
-    levels.map((level) => (level === current ? \`\${level} (current)\` : level))
-  );
-  return selected === undefined ? undefined : parseThinkingLevel(selected);
-}
-
-function parseThinkingLevel(value: string): ThinkingLevel | undefined {
-  const normalized = value.trim().split(/\\s+/u)[0]?.toLowerCase();
-  return levels.find((level) => level === normalized);
-}
-`;
-}

package/dist/src/pi/version.js

@@ -0,0 +1,25 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const packageMetadata = loadPackageMetadata();
+if (typeof packageMetadata.version !== "string") {
+    throw new Error("localpi package metadata is missing a string version");
+}
+export const localpiVersion = packageMetadata.version;
+function loadPackageMetadata() {
+    for (const packagePath of ["../../package.json", "../../../package.json"]) {
+        try {
+            return require(packagePath);
+        }
+        catch (error) {
+            if (!isModuleNotFound(error)) {
+                throw error;
+            }
+        }
+    }
+    throw new Error("localpi package metadata could not be loaded");
+}
+function isModuleNotFound(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        error.code === "MODULE_NOT_FOUND");
+}

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.