arisa 4.3.0 → 4.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "4.3.0",
+  "version": "4.3.3",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",

package/src/core/agent/agent-manager.js

@@ -3,10 +3,12 @@ import { readFile, stat, unlink } from "node:fs/promises";
 import { createAgentSession, DefaultResourceLoader, SessionManager, defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 import { createPiRuntime, hasProviderAuth } from "./pi-runtime.js";
+import { resolveChatModelSelection } from "./model-selection.js";
 import { appendArisaAgentsFile, arisaAgentsFile, arisaInstallDir, buildAgentRuntimeContext } from "./runtime-context.js";
 import { withTimeout } from "./prompt-timeout.js";
 import { buildPiToolPolicy, getCoreCodingTools } from "./core-tools.js";
 import { createSystemShellTool } from "./system-shell-tool.js";
+import { clampModelThinkingLevel } from "./pi-runtime.js";
 import { arisaHomeDir, getChatPiSessionsDir } from "../../runtime/paths.js";
 
 const piValidationTimeoutMs = 60_000;
@@ -126,9 +128,9 @@ export class AgentManager {
     this.sessions.delete(String(chatId));
   }
 
-  createSessionManager(chatId, workspaceDir = arisaInstallDir) {
+  createSessionManager(chatId, workspaceDir = arisaInstallDir, sessionRevision = 0) {
     const sessionKey = String(chatId);
-    const sessionDir = getChatPiSessionsDir(sessionKey);
+    const sessionDir = getChatPiSessionsDir(sessionKey, sessionRevision);
     if (this.pendingNewSessions.has(sessionKey)) {
       this.logger?.log("agent", `starting new persisted session for chat ${sessionKey}`);
       return { sessionManager: SessionManager.create(workspaceDir, sessionDir), isNewSession: true };
@@ -165,14 +167,21 @@ export class AgentManager {
 
   async getSessionContext(chatId, telegram) {
     const sessionKey = String(chatId);
-    const effectiveModelId = this.config.pi.model;
+    const modelSelection = resolveChatModelSelection(this.config, sessionKey);
+    const effectiveModelId = modelSelection.model;
+    const effectiveModelKey = `${modelSelection.provider}/${effectiveModelId}@${modelSelection.sessionRevision}`;
     if (this.sessions.has(sessionKey)) {
       const existing = this.sessions.get(sessionKey);
-      if (existing?.modelId === effectiveModelId) {
+      if (existing?.modelKey === effectiveModelKey) {
+        const desiredThinkingLevel = clampModelThinkingLevel(existing.session.model, modelSelection.thinkingLevel);
+        if (existing.session.thinkingLevel !== desiredThinkingLevel) {
+          this.logger?.log("agent", `updating effort for chat ${sessionKey}: ${existing.session.thinkingLevel} -> ${desiredThinkingLevel}`);
+          existing.session.setThinkingLevel(desiredThinkingLevel);
+        }
         this.logger?.log("agent", `reusing session for chat ${sessionKey}`);
         return existing;
       }
-      this.logger?.log("agent", `model changed for chat ${sessionKey}: ${existing?.modelId || "unknown"} -> ${effectiveModelId}; recreating session`);
+      this.logger?.log("agent", `model changed for chat ${sessionKey}: ${existing?.modelKey || "unknown"} -> ${effectiveModelKey}; recreating session`);
       this.sessions.delete(sessionKey);
       this.pendingNewSessions.add(sessionKey);
     }
@@ -186,15 +195,20 @@ export class AgentManager {
     if (requiresProviderAuth(model) && !this.config.pi.apiKey && !hasProviderAuth(this.config.pi.provider, { authStorage, modelRegistry })) {
       throw new Error(`No auth found for ${this.config.pi.provider}. Re-run bootstrap and complete login for this provider before Telegram starts.`);
     }
+    const thinkingLevel = clampModelThinkingLevel(model, modelSelection.thinkingLevel);
 
     const policy = buildPiToolPolicy({
       config: this.config,
       customToolNames: [...arisaToolNames, "system_shell"]
     });
     await assertDirectory(policy.workspaceDir, "pi.workspaceDir");
-    const { sessionManager, isNewSession } = this.createSessionManager(sessionKey, policy.workspaceDir);
+    const { sessionManager, isNewSession } = this.createSessionManager(
+      sessionKey,
+      policy.workspaceDir,
+      modelSelection.sessionRevision
+    );
     const hasExistingSession = sessionManager.buildSessionContext().messages.length > 0;
-    this.logger?.log("agent", `${hasExistingSession ? "resuming" : "creating"} session for chat ${sessionKey} with model ${effectiveModelId}`);
+    this.logger?.log("agent", `${hasExistingSession ? "resuming" : "creating"} session for chat ${sessionKey} with model ${effectiveModelId} effort ${thinkingLevel}`);
     const customTools = [
       ...this.createTools(telegram, chatId, policy),
       createSystemShellTool({ workspaceDir: policy.workspaceDir, shell: policy.shell })
@@ -210,6 +224,7 @@ export class AgentManager {
       authStorage,
       modelRegistry,
       model,
+      thinkingLevel,
       tools: policy.tools,
       excludeTools: policy.excludeTools,
       customTools,
@@ -224,7 +239,7 @@ export class AgentManager {
       })}`);
     }
 
-    const ctx = { session, modelId: effectiveModelId };
+    const ctx = { session, modelId: effectiveModelId, modelKey: effectiveModelKey };
     this.sessions.set(sessionKey, ctx);
     if (isNewSession) {
       this.pendingNewSessions.delete(sessionKey);

package/src/core/agent/auth-flow.js

@@ -9,6 +9,7 @@ const authInvalidatedPatterns = [
 
 const missingAuthPatterns = [
   /no auth found/i,
+  /no api key(?: found)? for/i,
   /auth(?:entication)? .*missing/i
 ];
 

package/src/core/agent/model-selection.js

@@ -0,0 +1,65 @@
+function chatKey(chatId) {
+  return String(chatId);
+}
+
+function normalizeSessionRevision(sessionRevision) {
+  if (sessionRevision == null) return 0;
+  if (!Number.isSafeInteger(sessionRevision) || sessionRevision < 0) {
+    throw new Error("Invalid model session revision");
+  }
+  return sessionRevision;
+}
+
+export function resolveChatModelSelection(config, chatId) {
+  const selection = config.pi.chatModels?.[chatKey(chatId)];
+  if (!selection || selection.provider !== config.pi.provider) {
+    return {
+      provider: config.pi.provider,
+      model: config.pi.model,
+      thinkingLevel: config.pi.thinkingLevel,
+      sessionRevision: 0
+    };
+  }
+  const sessionRevision = normalizeSessionRevision(selection.sessionRevision);
+  return {
+    provider: selection.provider,
+    model: selection.model,
+    thinkingLevel: selection.thinkingLevel ?? config.pi.thinkingLevel,
+    sessionRevision
+  };
+}
+
+export function resolveChatModel(config, chatId) {
+  return resolveChatModelSelection(config, chatId).model;
+}
+
+export function resolveChatThinkingLevel(config, chatId) {
+  return resolveChatModelSelection(config, chatId).thinkingLevel;
+}
+
+export function selectChatModel(config, chatId, model, { thinkingLevel } = {}) {
+  if (model.provider !== config.pi.provider) {
+    throw new Error(`Cannot select model from provider ${model.provider}; active provider is ${config.pi.provider}`);
+  }
+  config.pi.chatModels ||= {};
+  const key = chatKey(chatId);
+  const sessionRevision = (config.pi.chatModels[key]?.sessionRevision || 0) + 1;
+  config.pi.chatModels[key] = {
+    provider: model.provider,
+    model: model.id,
+    thinkingLevel,
+    sessionRevision
+  };
+}
+
+export function selectChatThinkingLevel(config, chatId, thinkingLevel) {
+  config.pi.chatModels ||= {};
+  const key = chatKey(chatId);
+  const current = resolveChatModelSelection(config, chatId);
+  config.pi.chatModels[key] = {
+    provider: current.provider,
+    model: current.model,
+    thinkingLevel,
+    sessionRevision: current.sessionRevision
+  };
+}

package/src/core/agent/pi-runtime.js

@@ -53,6 +53,55 @@ export function listProviderModels(provider, runtime = createPiRuntime()) {
     .sort((a, b) => compareText(a.name || a.id, b.name || b.id));
 }
 
+export function formatPiModelOption(model) {
+  const capabilities = [
+    model.reasoning ? "reasoning" : null,
+    model.input?.includes("image") ? "image" : null
+  ].filter(Boolean).join(", ");
+  return capabilities ? `${model.id} [${capabilities}]` : model.id;
+}
+
+/** Mirrors @earendil-works/pi-ai getSupportedThinkingLevels for the active model. */
+const EXTENDED_THINKING_LEVELS = Object.freeze([
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+]);
+
+export function listModelThinkingLevels(model) {
+  if (!model?.reasoning) return ["off"];
+  return EXTENDED_THINKING_LEVELS.filter((level) => {
+    const mapped = model.thinkingLevelMap?.[level];
+    if (mapped === null) return false;
+    if (level === "xhigh" || level === "max") return mapped !== undefined;
+    return true;
+  });
+}
+
+export function clampModelThinkingLevel(model, level) {
+  const availableLevels = listModelThinkingLevels(model);
+  if (availableLevels.includes(level)) return level;
+  const requestedIndex = EXTENDED_THINKING_LEVELS.indexOf(level);
+  if (requestedIndex === -1) return availableLevels[0] ?? "off";
+  for (let i = requestedIndex; i < EXTENDED_THINKING_LEVELS.length; i++) {
+    const candidate = EXTENDED_THINKING_LEVELS[i];
+    if (availableLevels.includes(candidate)) return candidate;
+  }
+  for (let i = requestedIndex - 1; i >= 0; i--) {
+    const candidate = EXTENDED_THINKING_LEVELS[i];
+    if (availableLevels.includes(candidate)) return candidate;
+  }
+  return availableLevels[0] ?? "off";
+}
+
+export function modelSupportsThinking(model) {
+  return listModelThinkingLevels(model).some((level) => level !== "off");
+}
+
 export function findPiModel({ provider, model, apiKey } = {}) {
   const runtime = createPiRuntime({ provider, apiKey });
   return {

package/src/core/config/config-defaults.js

@@ -14,9 +14,25 @@ export const daemonConfigDefaults = Object.freeze({
   queuePollIntervalMs: 250
 });
 
+export const telegramConfigDefaults = Object.freeze({
+  modelPickerPageSize: 8
+});
+
+export const piConfigDefaults = Object.freeze({
+  thinkingLevel: "medium"
+});
+
 export function applyConfigDefaults(config) {
   return {
     ...config,
+    telegram: {
+      ...telegramConfigDefaults,
+      ...(config.telegram || {})
+    },
+    pi: {
+      ...piConfigDefaults,
+      ...(config.pi || {})
+    },
     daemons: {
       ...daemonConfigDefaults,
       ...(config.daemons || {})

package/src/core/tools/daemon-processes.js

@@ -337,11 +337,16 @@ async function listChatDaemonRecords() {
   const records = [];
   for (const chatEntry of chatEntries) {
     if (!chatEntry.isDirectory()) continue;
+    let scope;
+    try {
+      scope = normalizeDaemonScope({ type: "chat", chatId: chatEntry.name });
+    } catch {
+      continue;
+    }
     const toolsRoot = path.join(chatsDir, chatEntry.name, "state", "tools");
     const toolEntries = await readdir(toolsRoot, { withFileTypes: true }).catch(() => []);
     for (const toolEntry of toolEntries) {
       if (!toolEntry.isDirectory()) continue;
-      const scope = { type: "chat", chatId: chatEntry.name };
       const meta = await readJson(daemonPaths({ toolName: toolEntry.name, scope }).metaFile, null);
       if (meta?.toolName && meta?.entryPath) records.push(meta);
     }

package/src/runtime/bootstrap.js

@@ -5,9 +5,10 @@ import { stdin as input, stdout as output } from "node:process";
 import { spawn } from "node:child_process";
 import { Bot } from "grammy";
 import { createPiOAuthLogin } from "../core/agent/pi-auth-login.js";
-import { createPiRuntime, hasProviderAuth, listPiProviders, listProviderModels, supportsProviderOAuth } from "../core/agent/pi-runtime.js";
-import { applyConfigDefaults } from "../core/config/config-defaults.js";
+import { createPiRuntime, formatPiModelOption, hasProviderAuth, listPiProviders, listProviderModels, supportsProviderOAuth } from "../core/agent/pi-runtime.js";
+import { applyConfigDefaults, telegramConfigDefaults } from "../core/config/config-defaults.js";
 import { buildDeviceCodeTelegramMessage } from "../transport/telegram/device-code-message.js";
+import { buildPagedInlineKeyboard } from "../transport/telegram/paged-inline-keyboard.js";
 import { configFile, ensureArisaHome } from "./paths.js";
 
 const ARISA_BANNER = [
@@ -100,30 +101,6 @@ function parseYesNo(value, fallback = true) {
   return null;
 }
 
-function buildPagedInlineKeyboard(action, items, { page = 0, pageSize = 8 } = {}) {
-  const pageCount = Math.max(1, Math.ceil(items.length / pageSize));
-  const currentPage = Math.max(0, Math.min(pageCount - 1, page));
-  const startIndex = currentPage * pageSize;
-  const rows = items.slice(startIndex, startIndex + pageSize).map((item, index) => ([{
-    text: item.text,
-    callback_data: `${action}:${startIndex + index}`
-  }]));
-
-  if (pageCount > 1) {
-    const navigation = [];
-    if (currentPage > 0) {
-      navigation.push({ text: "Previous", callback_data: `${action}-page:${currentPage - 1}` });
-    }
-    navigation.push({ text: `${currentPage + 1}/${pageCount}`, callback_data: "noop:page" });
-    if (currentPage < pageCount - 1) {
-      navigation.push({ text: "Next", callback_data: `${action}-page:${currentPage + 1}` });
-    }
-    rows.push(navigation);
-  }
-
-  return { inline_keyboard: rows };
-}
-
 function getIncomingChatMeta(ctx) {
   return {
     languageCode: ctx.from?.language_code || "",
@@ -138,11 +115,6 @@ function formatProviderOption(item) {
   return `${item.provider} (${item.modelCount} models, ${authLabel})`;
 }
 
-function formatModelOption(model) {
-  const capabilities = [model.reasoning ? "reasoning" : null, model.input?.includes("image") ? "image" : null].filter(Boolean).join(", ");
-  return capabilities ? `${model.id} [${capabilities}]` : model.id;
-}
-
 function selectPiLoginOption(options = []) {
   return options.find((option) => /device/i.test(`${option.id} ${option.label}`))
     || options.find((option) => /browser|oauth|web/i.test(`${option.id} ${option.label}`))
@@ -215,7 +187,7 @@ async function collectCliBootstrapChoices({ telegramApiKey, rl, ask }) {
   const models = sortBootstrapModels(selectedProvider.provider, listProviderModels(selectedProvider.provider, runtime));
   console.log(`\nAvailable models for ${selectedProvider.provider}:`);
   models.forEach((model, index) => {
-    console.log(`${index + 1}. ${formatModelOption(model)}`);
+    console.log(`${index + 1}. ${formatPiModelOption(model)}`);
   });
 
   const selectedModel = selectByIndex(models, await ask("Select Pi model by number", "1"));
@@ -326,14 +298,20 @@ async function runTelegramBootstrap({ telegramApiKey, setupToken, botInfo }) {
   const askProvider = async (ctx = null, page = 0) => {
     state = "provider";
     await showSetupPrompt(ctx, "Select the Pi provider Arisa should use:", {
-      reply_markup: buildPagedInlineKeyboard("provider", providers.map((provider) => ({ text: formatProviderOption(provider) })), { page })
+      reply_markup: buildPagedInlineKeyboard("provider", providers.map((provider) => ({ text: formatProviderOption(provider) })), {
+        page,
+        pageSize: telegramConfigDefaults.modelPickerPageSize
+      })
     });
   };
 
   const askModel = async (ctx = null, page = 0) => {
     state = "model";
     const models = sortBootstrapModels(selectedProvider.provider, listProviderModels(selectedProvider.provider, createPiRuntime()));
-    const keyboard = buildPagedInlineKeyboard("model", models.map((model) => ({ text: formatModelOption(model) })), { page });
+    const keyboard = buildPagedInlineKeyboard("model", models.map((model) => ({ text: formatPiModelOption(model) })), {
+      page,
+      pageSize: telegramConfigDefaults.modelPickerPageSize
+    });
     keyboard.inline_keyboard.push([{ text: "Back to providers", callback_data: "back:provider" }]);
     await showSetupPrompt(ctx, `Select the model for ${selectedProvider.provider}:`, {
       reply_markup: keyboard

package/src/runtime/paths.js

@@ -72,8 +72,14 @@ export function getDaemonInstanceDir(toolName, scope = { type: "global" }) {
     : path.join(getChatToolStateDir(normalized.chatId, toolName), "daemon");
 }
 
-export function getChatPiSessionsDir(chatId) {
-  return path.join(getChatDir(chatId), "state", "pi-sessions");
+export function getChatPiSessionsDir(chatId, sessionRevision = 0) {
+  if (!Number.isSafeInteger(sessionRevision) || sessionRevision < 0) {
+    throw new Error(`Invalid Pi session revision: ${sessionRevision}`);
+  }
+  const sessionsDir = path.join(getChatDir(chatId), "state", "pi-sessions");
+  return sessionRevision === 0
+    ? sessionsDir
+    : path.join(sessionsDir, String(sessionRevision));
 }
 
 export function getToolDir(toolName) {

package/src/transport/telegram/bot.js

@@ -3,9 +3,12 @@ import path from "node:path";
 import { authorizeChat } from "./auth.js";
 import { captureIncomingArtifact, formatLocationText } from "./media.js";
 import { buildDeviceCodeTelegramMessage } from "./device-code-message.js";
+import { buildEffortPicker, buildModelPicker, parseEffortPickerAction, parseModelPickerAction } from "./model-picker.js";
 import { renderTelegramHtml } from "./text-format.js";
 import { buildPiAuthRecoveryBlockedMessage, buildPiAuthTelegramMessage, getErrorMessage, getPiAuthIssue, getPiAuthStatus } from "../../core/agent/auth-flow.js";
 import { createPiOAuthLogin } from "../../core/agent/pi-auth-login.js";
+import { resolveChatModel, resolveChatThinkingLevel, selectChatModel, selectChatThinkingLevel } from "../../core/agent/model-selection.js";
+import { clampModelThinkingLevel, createPiRuntime, listModelThinkingLevels, listProviderModels, modelSupportsThinking } from "../../core/agent/pi-runtime.js";
 import { normalizeArtifactForReasoning, shouldNormalizeArtifactToText } from "../../core/artifacts/normalize-for-reasoning.js";
 
 const slowPromptNoticeMs = 300_000;
@@ -410,6 +413,102 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     return perChatState.get(chatId);
   }
 
+  function getProviderModels() {
+    const runtime = createPiRuntime({
+      provider: config.pi.provider,
+      apiKey: config.pi.apiKey
+    });
+    return listProviderModels(config.pi.provider, runtime);
+  }
+
+  async function showModelPicker(ctx, page = 0) {
+    const picker = buildModelPicker({
+      provider: config.pi.provider,
+      models: getProviderModels(),
+      selectedModelId: resolveChatModel(config, ctx.chat.id),
+      selectedThinkingLevel: resolveChatThinkingLevel(config, ctx.chat.id),
+      page,
+      pageSize: config.telegram.modelPickerPageSize
+    });
+    const extra = { reply_markup: picker.replyMarkup };
+    const messageId = ctx.callbackQuery?.message?.message_id;
+    if (messageId) {
+      return ctx.api.editMessageText(ctx.chat.id, messageId, picker.text, extra);
+    }
+    return ctx.reply(picker.text, extra);
+  }
+
+  async function showEffortPicker(ctx, { model, modelIndex, selectedThinkingLevel } = {}) {
+    const models = getProviderModels();
+    const resolvedModel = model || models.find((item) => item.id === resolveChatModel(config, ctx.chat.id));
+    if (!resolvedModel) {
+      throw new Error(`Model not found for provider ${config.pi.provider}`);
+    }
+    if (!modelSupportsThinking(resolvedModel)) {
+      const text = `${resolvedModel.provider}/${resolvedModel.id} does not support effort levels.`;
+      if (ctx.callbackQuery?.message?.message_id) {
+        return ctx.api.editMessageText(ctx.chat.id, ctx.callbackQuery.message.message_id, text);
+      }
+      return ctx.reply(text);
+    }
+    const levels = listModelThinkingLevels(resolvedModel);
+    const picker = buildEffortPicker({
+      provider: resolvedModel.provider,
+      modelId: resolvedModel.id,
+      levels,
+      selectedThinkingLevel: selectedThinkingLevel
+        ?? clampModelThinkingLevel(resolvedModel, resolveChatThinkingLevel(config, ctx.chat.id)),
+      modelIndex
+    });
+    const extra = { reply_markup: picker.replyMarkup };
+    const messageId = ctx.callbackQuery?.message?.message_id;
+    if (messageId) {
+      return ctx.api.editMessageText(ctx.chat.id, messageId, picker.text, extra);
+    }
+    return ctx.reply(picker.text, extra);
+  }
+
+  async function persistChatModel(chatId, model, thinkingLevel) {
+    const key = chatKey(chatId);
+    const hadSelections = Boolean(config.pi.chatModels);
+    const previousSelection = config.pi.chatModels?.[key];
+    const level = clampModelThinkingLevel(model, thinkingLevel ?? resolveChatThinkingLevel(config, chatId));
+    selectChatModel(config, chatId, model, { thinkingLevel: level });
+    try {
+      await saveConfig(config);
+    } catch (error) {
+      if (previousSelection) {
+        config.pi.chatModels[key] = previousSelection;
+      } else {
+        delete config.pi.chatModels[key];
+        if (!hadSelections) delete config.pi.chatModels;
+      }
+      throw error;
+    }
+    agentManager.resetSession(chatId);
+    return level;
+  }
+
+  async function persistChatEffort(chatId, model, thinkingLevel) {
+    const key = chatKey(chatId);
+    const hadSelections = Boolean(config.pi.chatModels);
+    const previousSelection = config.pi.chatModels?.[key];
+    const level = clampModelThinkingLevel(model, thinkingLevel);
+    selectChatThinkingLevel(config, chatId, level);
+    try {
+      await saveConfig(config);
+    } catch (error) {
+      if (previousSelection) {
+        config.pi.chatModels[key] = previousSelection;
+      } else {
+        delete config.pi.chatModels[key];
+        if (!hadSelections) delete config.pi.chatModels;
+      }
+      throw error;
+    }
+    return level;
+  }
+
   async function buildIncomingPrompt(ctx) {
     const chatId = ctx.chat.id;
     logger?.log("telegram", `message ${ctx.msg.message_id} in chat ${chatId}`);
@@ -684,6 +783,18 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     await handleNewCommand(ctx);
   });
 
+  bot.command("model", async (ctx) => {
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
+    if (!auth.ok) return;
+    await showModelPicker(ctx);
+  });
+
+  bot.command("effort", async (ctx) => {
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
+    if (!auth.ok) return;
+    await showEffortPicker(ctx);
+  });
+
   bot.command("auth", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
@@ -717,6 +828,170 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     }
   });
 
+  bot.on("callback_query:data", async (ctx, next) => {
+    const modelAction = parseModelPickerAction(ctx.callbackQuery.data);
+    const effortAction = modelAction ? null : parseEffortPickerAction(ctx.callbackQuery.data);
+    const action = modelAction || effortAction;
+    if (!action) return next();
+    if (action.type === "noop") {
+      await ctx.answerCallbackQuery();
+      return;
+    }
+
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig });
+    if (!auth.ok) {
+      await ctx.answerCallbackQuery({ text: "This chat is not authorized.", show_alert: true });
+      return;
+    }
+
+    try {
+      if (action.type === "page") {
+        await showModelPicker(ctx, action.value);
+        await ctx.answerCallbackQuery();
+        return;
+      }
+
+      if (getChatState(ctx.chat.id).processing) {
+        await ctx.answerCallbackQuery({
+          text: action.type === "effort" || action.type === "model-effort"
+            ? "Wait for the current response before changing effort."
+            : "Wait for the current response before changing models.",
+          show_alert: true
+        });
+        return;
+      }
+
+      const models = getProviderModels();
+
+      if (action.type === "select") {
+        const model = models[action.value];
+        if (!model) {
+          await ctx.answerCallbackQuery({
+            text: "This model list is no longer current. Run /model again.",
+            show_alert: true
+          });
+          return;
+        }
+
+        if (modelSupportsThinking(model)) {
+          await showEffortPicker(ctx, {
+            model,
+            modelIndex: action.value,
+            selectedThinkingLevel: clampModelThinkingLevel(model, resolveChatThinkingLevel(config, ctx.chat.id))
+          });
+          await ctx.answerCallbackQuery({ text: `Choose effort for ${model.id}.` });
+          return;
+        }
+
+        const currentModelId = resolveChatModel(config, ctx.chat.id);
+        const currentEffort = resolveChatThinkingLevel(config, ctx.chat.id);
+        if (model.id === currentModelId && currentEffort === "off") {
+          await ctx.answerCallbackQuery({ text: `Already using ${model.id}.` });
+          return;
+        }
+
+        await persistChatModel(ctx.chat.id, model, "off");
+        await ctx.api.editMessageText(
+          ctx.chat.id,
+          ctx.callbackQuery.message.message_id,
+          `Model changed to ${model.provider}/${model.id}.\nA new chat context will start with your next message.`
+        );
+        await ctx.answerCallbackQuery({ text: `Using ${model.id}.` });
+        return;
+      }
+
+      if (action.type === "model-effort") {
+        const model = models[action.modelIndex];
+        if (!model) {
+          await ctx.answerCallbackQuery({
+            text: "This model list is no longer current. Run /model again.",
+            show_alert: true
+          });
+          return;
+        }
+        const levels = listModelThinkingLevels(model);
+        if (!levels.includes(action.level)) {
+          await ctx.answerCallbackQuery({
+            text: "That effort level is not available for this model.",
+            show_alert: true
+          });
+          return;
+        }
+
+        const currentModelId = resolveChatModel(config, ctx.chat.id);
+        const currentEffort = resolveChatThinkingLevel(config, ctx.chat.id);
+        if (model.id === currentModelId && action.level === currentEffort) {
+          await ctx.answerCallbackQuery({ text: `Already using ${model.id} at ${action.level}.` });
+          return;
+        }
+
+        if (model.id === currentModelId) {
+          await persistChatEffort(ctx.chat.id, model, action.level);
+          await ctx.api.editMessageText(
+            ctx.chat.id,
+            ctx.callbackQuery.message.message_id,
+            `Effort set to ${action.level} for ${model.provider}/${model.id}.`
+          );
+          await ctx.answerCallbackQuery({ text: `Effort: ${action.level}.` });
+          return;
+        }
+
+        await persistChatModel(ctx.chat.id, model, action.level);
+        await ctx.api.editMessageText(
+          ctx.chat.id,
+          ctx.callbackQuery.message.message_id,
+          `Model changed to ${model.provider}/${model.id} (effort: ${action.level}).\nA new chat context will start with your next message.`
+        );
+        await ctx.answerCallbackQuery({ text: `Using ${model.id} / ${action.level}.` });
+        return;
+      }
+
+      if (action.type === "effort") {
+        const model = models.find((item) => item.id === resolveChatModel(config, ctx.chat.id));
+        if (!model) {
+          await ctx.answerCallbackQuery({
+            text: "Current model is unavailable. Run /model again.",
+            show_alert: true
+          });
+          return;
+        }
+        if (!modelSupportsThinking(model)) {
+          await ctx.answerCallbackQuery({
+            text: "This model does not support effort levels.",
+            show_alert: true
+          });
+          return;
+        }
+        const levels = listModelThinkingLevels(model);
+        if (!levels.includes(action.level)) {
+          await ctx.answerCallbackQuery({
+            text: "That effort level is not available for this model.",
+            show_alert: true
+          });
+          return;
+        }
+        const currentEffort = resolveChatThinkingLevel(config, ctx.chat.id);
+        if (action.level === currentEffort) {
+          await ctx.answerCallbackQuery({ text: `Already using effort ${action.level}.` });
+          return;
+        }
+        await persistChatEffort(ctx.chat.id, model, action.level);
+        await ctx.api.editMessageText(
+          ctx.chat.id,
+          ctx.callbackQuery.message.message_id,
+          `Effort set to ${action.level} for ${model.provider}/${model.id}.`
+        );
+        await ctx.answerCallbackQuery({ text: `Effort: ${action.level}.` });
+      }
+    } catch (error) {
+      logger?.error("telegram", `model selection failed for chat ${ctx.chat.id}: ${getErrorMessage(error)}`);
+      await ctx.answerCallbackQuery({
+        text: "Could not change the model or effort.",
+        show_alert: true
+      }).catch(() => {});
+    }
+  });
+
   bot.on("message", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
@@ -753,6 +1028,8 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
       config.telegram.chatMeta ||= {};
       await bot.api.setMyCommands([
         { command: "new", description: "Start a new chat context" },
+        { command: "model", description: "Choose the model for this chat" },
+        { command: "effort", description: "Choose reasoning effort for this chat" },
         { command: "auth", description: "Show Pi authentication status" }
       ]);
       if (!taskTimer) {

package/src/transport/telegram/model-picker.js

@@ -0,0 +1,69 @@
+import { formatPiModelOption } from "../../core/agent/pi-runtime.js";
+import { buildPagedInlineKeyboard } from "./paged-inline-keyboard.js";
+
+export function parseModelPickerAction(data) {
+  if (data === "noop:page") return { type: "noop", value: null };
+  const match = /^(model|model-page):(\d+)$/.exec(String(data || ""));
+  if (!match) return null;
+  return {
+    type: match[1] === "model" ? "select" : "page",
+    value: Number(match[2])
+  };
+}
+
+export function parseEffortPickerAction(data) {
+  if (data === "noop:page") return { type: "noop", value: null };
+  const modelEffort = /^model-effort:(\d+):([a-z]+)$/.exec(String(data || ""));
+  if (modelEffort) {
+    return {
+      type: "model-effort",
+      modelIndex: Number(modelEffort[1]),
+      level: modelEffort[2]
+    };
+  }
+  const effort = /^effort:([a-z]+)$/.exec(String(data || ""));
+  if (effort) {
+    return {
+      type: "effort",
+      level: effort[1]
+    };
+  }
+  return null;
+}
+
+export function buildModelPicker({ provider, models, selectedModelId, selectedThinkingLevel, page, pageSize }) {
+  if (!models.length) {
+    throw new Error(`No models available for provider ${provider}`);
+  }
+  const items = models.map((model) => ({
+    text: `${model.id === selectedModelId ? "✓ " : ""}${formatPiModelOption(model)}`
+  }));
+  const effortLine = selectedThinkingLevel ? `\nEffort: ${selectedThinkingLevel}` : "";
+  return {
+    text: `Current model: ${provider}/${selectedModelId}${effortLine}\nSelect a model for this chat:`,
+    replyMarkup: buildPagedInlineKeyboard("model", items, { page, pageSize })
+  };
+}
+
+export function buildEffortPicker({
+  provider,
+  modelId,
+  levels,
+  selectedThinkingLevel,
+  modelIndex
+}) {
+  if (!levels.length) {
+    throw new Error(`No effort levels available for ${provider}/${modelId}`);
+  }
+  const rows = levels.map((level) => ([{
+    text: `${level === selectedThinkingLevel ? "✓ " : ""}${level}`,
+    callback_data: modelIndex == null ? `effort:${level}` : `model-effort:${modelIndex}:${level}`
+  }]));
+  const scope = modelIndex == null
+    ? `Current model: ${provider}/${modelId}\nSelect effort for this chat:`
+    : `Model: ${provider}/${modelId}\nSelect effort:`;
+  return {
+    text: scope,
+    replyMarkup: { inline_keyboard: rows }
+  };
+}

package/src/transport/telegram/paged-inline-keyboard.js

@@ -0,0 +1,30 @@
+function requirePositiveInteger(value, name) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+}
+
+export function buildPagedInlineKeyboard(action, items, { page = 0, pageSize }) {
+  requirePositiveInteger(pageSize, "pageSize");
+  const pageCount = Math.max(1, Math.ceil(items.length / pageSize));
+  const currentPage = Math.max(0, Math.min(pageCount - 1, page));
+  const startIndex = currentPage * pageSize;
+  const rows = items.slice(startIndex, startIndex + pageSize).map((item, index) => ([{
+    text: item.text,
+    callback_data: `${action}:${startIndex + index}`
+  }]));
+
+  if (pageCount > 1) {
+    const navigation = [];
+    if (currentPage > 0) {
+      navigation.push({ text: "Previous", callback_data: `${action}-page:${currentPage - 1}` });
+    }
+    navigation.push({ text: `${currentPage + 1}/${pageCount}`, callback_data: "noop:page" });
+    if (currentPage < pageCount - 1) {
+      navigation.push({ text: "Next", callback_data: `${action}-page:${currentPage + 1}` });
+    }
+    rows.push(navigation);
+  }
+
+  return { inline_keyboard: rows };
+}

package/test/auth-flow.test.js

@@ -25,6 +25,8 @@ test("classifies invalidated Pi authentication tokens", () => {
 test("classifies missing Pi authentication", () => {
   for (const error of [
     new Error("No auth found for provider"),
+    new Error("No API key for provider: openai-codex"),
+    new Error('No API key found for "openai-codex"'),
     new Error("authentication credentials are missing")
   ]) {
     assert.deepEqual(getPiAuthIssue(error), {

package/test/daemon-runtime.test.js

@@ -116,6 +116,38 @@ test("isolates daemon process files and context by chat scope", async () => {
   await Promise.all([first.stop(), second.stop()]);
 });
 
+test("supervisor ignores invalid chat directories and recovers valid daemons", async () => {
+  const invalidChatDir = path.join(homeDir, "chats", "24137857-c513-4f53-b39d-1b28f51ebbb6");
+  await mkdir(path.join(invalidChatDir, "state", "tools", "orphaned-tool"), { recursive: true });
+
+  const runtime = runtimeFor({ type: "chat", chatId: "202" }, {
+    autoStart: true,
+    startupContext: { health: "ok" }
+  });
+  let supervisor;
+
+  try {
+    await runtime.submit({ value: "before" }, { timeoutMs: 1_000 });
+    const oldPid = await runtime.getPid();
+    process.kill(oldPid, "SIGKILL");
+    await waitFor(() => !isProcessAlive(oldPid));
+
+    supervisor = createToolProcessSupervisor({ policy });
+    await supervisor.start();
+
+    const newPid = await waitFor(async () => {
+      const pid = await runtime.getPid();
+      const status = await readJson(runtime.paths.statusFile, {});
+      return pid && pid !== oldPid && status.state === "ready" ? pid : null;
+    });
+    assert.notEqual(newPid, oldPid);
+  } finally {
+    await supervisor?.stop();
+    await runtime.stop().catch(() => {});
+    await rm(invalidChatDir, { recursive: true, force: true });
+  }
+});
+
 test("rejects stale readiness even when the pid is alive", async () => {
   const status = {
     state: "ready",

package/test/model-selection.test.js

@@ -0,0 +1,195 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import test from "node:test";
+import {
+  resolveChatModel,
+  resolveChatModelSelection,
+  resolveChatThinkingLevel,
+  selectChatModel,
+  selectChatThinkingLevel
+} from "../src/core/agent/model-selection.js";
+import { applyConfigDefaults, piConfigDefaults, telegramConfigDefaults } from "../src/core/config/config-defaults.js";
+import {
+  clampModelThinkingLevel,
+  listModelThinkingLevels,
+  modelSupportsThinking
+} from "../src/core/agent/pi-runtime.js";
+import { getChatPiSessionsDir } from "../src/runtime/paths.js";
+import {
+  buildEffortPicker,
+  buildModelPicker,
+  parseEffortPickerAction,
+  parseModelPickerAction
+} from "../src/transport/telegram/model-picker.js";
+
+function createConfig() {
+  return applyConfigDefaults({
+    telegram: {},
+    pi: {
+      provider: "openai-codex",
+      model: "gpt-default"
+    }
+  });
+}
+
+test("resolves the default model until a chat selects one", () => {
+  const config = createConfig();
+
+  assert.equal(resolveChatModel(config, 123), "gpt-default");
+  assert.equal(resolveChatThinkingLevel(config, 123), piConfigDefaults.thinkingLevel);
+
+  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-selected" }, { thinkingLevel: "high" });
+
+  assert.equal(resolveChatModel(config, 123), "gpt-selected");
+  assert.equal(resolveChatThinkingLevel(config, 123), "high");
+  assert.equal(resolveChatModel(config, 456), "gpt-default");
+  assert.deepEqual(config.pi.chatModels["123"], {
+    provider: "openai-codex",
+    model: "gpt-selected",
+    thinkingLevel: "high",
+    sessionRevision: 1
+  });
+});
+
+test("starts a distinct persisted Pi session revision on every model change", () => {
+  const config = createConfig();
+
+  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-a" }, { thinkingLevel: "medium" });
+  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-b" }, { thinkingLevel: "high" });
+
+  assert.equal(config.pi.chatModels["123"].sessionRevision, 2);
+  assert.equal(
+    getChatPiSessionsDir(123, config.pi.chatModels["123"].sessionRevision),
+    path.join(getChatPiSessionsDir(123), "2")
+  );
+});
+
+test("updates effort without bumping the session revision", () => {
+  const config = createConfig();
+
+  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-a" }, { thinkingLevel: "medium" });
+  selectChatThinkingLevel(config, 123, "high");
+
+  assert.deepEqual(resolveChatModelSelection(config, 123), {
+    provider: "openai-codex",
+    model: "gpt-a",
+    thinkingLevel: "high",
+    sessionRevision: 1
+  });
+});
+
+test("ignores a chat selection from a different active provider", () => {
+  const config = createConfig();
+  config.pi.chatModels = {
+    123: { provider: "anthropic", model: "claude-selected", thinkingLevel: "high", sessionRevision: 1 }
+  };
+
+  assert.equal(resolveChatModel(config, 123), "gpt-default");
+  assert.equal(resolveChatThinkingLevel(config, 123), piConfigDefaults.thinkingLevel);
+});
+
+test("rejects selecting a model outside the active provider", () => {
+  const config = createConfig();
+
+  assert.throws(
+    () => selectChatModel(config, 123, { provider: "anthropic", id: "claude-selected" }),
+    /active provider is openai-codex/
+  );
+});
+
+test("builds a paged model picker and marks the current model", () => {
+  const models = [
+    { provider: "openai-codex", id: "gpt-a", reasoning: false, input: ["text"] },
+    { provider: "openai-codex", id: "gpt-b", reasoning: true, input: ["text", "image"] },
+    { provider: "openai-codex", id: "gpt-c", reasoning: false, input: ["text"] }
+  ];
+
+  const picker = buildModelPicker({
+    provider: "openai-codex",
+    models,
+    selectedModelId: "gpt-b",
+    selectedThinkingLevel: "high",
+    page: 0,
+    pageSize: 2
+  });
+
+  assert.match(picker.text, /openai-codex\/gpt-b/);
+  assert.match(picker.text, /Effort: high/);
+  assert.equal(picker.replyMarkup.inline_keyboard[0][0].callback_data, "model:0");
+  assert.match(picker.replyMarkup.inline_keyboard[1][0].text, /^✓ gpt-b \[reasoning, image\]$/);
+  assert.equal(picker.replyMarkup.inline_keyboard[2][1].callback_data, "model-page:1");
+});
+
+test("builds an effort picker for the current model or pending model choice", () => {
+  const current = buildEffortPicker({
+    provider: "openai-codex",
+    modelId: "gpt-b",
+    levels: ["off", "low", "medium", "high"],
+    selectedThinkingLevel: "medium"
+  });
+  assert.match(current.text, /Current model: openai-codex\/gpt-b/);
+  assert.equal(current.replyMarkup.inline_keyboard[1][0].callback_data, "effort:low");
+  assert.match(current.replyMarkup.inline_keyboard[2][0].text, /^✓ medium$/);
+
+  const pending = buildEffortPicker({
+    provider: "openai-codex",
+    modelId: "gpt-b",
+    levels: ["off", "high"],
+    selectedThinkingLevel: "high",
+    modelIndex: 4
+  });
+  assert.match(pending.text, /^Model: openai-codex\/gpt-b/);
+  assert.equal(pending.replyMarkup.inline_keyboard[1][0].callback_data, "model-effort:4:high");
+});
+
+test("parses only model picker callback data", () => {
+  assert.deepEqual(parseModelPickerAction("model:12"), { type: "select", value: 12 });
+  assert.deepEqual(parseModelPickerAction("model-page:2"), { type: "page", value: 2 });
+  assert.deepEqual(parseModelPickerAction("noop:page"), { type: "noop", value: null });
+  assert.equal(parseModelPickerAction("provider:1"), null);
+  assert.equal(parseModelPickerAction("model:-1"), null);
+  assert.equal(parseModelPickerAction("effort:high"), null);
+});
+
+test("parses effort picker callback data", () => {
+  assert.deepEqual(parseEffortPickerAction("effort:high"), { type: "effort", level: "high" });
+  assert.deepEqual(parseEffortPickerAction("model-effort:3:medium"), {
+    type: "model-effort",
+    modelIndex: 3,
+    level: "medium"
+  });
+  assert.deepEqual(parseEffortPickerAction("noop:page"), { type: "noop", value: null });
+  assert.equal(parseEffortPickerAction("model:1"), null);
+});
+
+test("centralizes picker defaults in config", () => {
+  const config = applyConfigDefaults({
+    telegram: {},
+    pi: { provider: "openai-codex", model: "gpt-default" }
+  });
+
+  assert.equal(config.telegram.modelPickerPageSize, telegramConfigDefaults.modelPickerPageSize);
+  assert.equal(config.pi.thinkingLevel, piConfigDefaults.thinkingLevel);
+});
+
+test("lists and clamps thinking levels from model capabilities", () => {
+  const reasoning = {
+    reasoning: true,
+    thinkingLevelMap: { xhigh: "xhigh", minimal: "low", max: null }
+  };
+  assert.deepEqual(listModelThinkingLevels(reasoning), [
+    "off",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh"
+  ]);
+  assert.equal(clampModelThinkingLevel(reasoning, "max"), "xhigh");
+  assert.equal(modelSupportsThinking(reasoning), true);
+
+  const plain = { reasoning: false };
+  assert.deepEqual(listModelThinkingLevels(plain), ["off"]);
+  assert.equal(clampModelThinkingLevel(plain, "high"), "off");
+  assert.equal(modelSupportsThinking(plain), false);
+});