@companion-ai/feynman 0.5.40 → 0.5.42

package/.feynman/settings.json

@@ -2,5 +2,6 @@
   "theme": "feynman",
   "quietStartup": true,
   "collapseChangelog": true,
-  "editorPaddingX": 1
+  "editorPaddingX": 1,
+  "showHardwareCursor": true
 }

package/.feynman/themes/feynman.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+  "$schema": "https://pi.dev/schemas/theme.schema.json",
   "name": "feynman",
   "vars": {
     "ink": "#d3c6aa",

package/RELEASES.md

@@ -6,6 +6,32 @@ GitHub release notes are generated from the matching `## vX.Y.Z` section in this
 
 ## Unreleased
 
+## v0.5.42 - 2026-10-13
+
+- **Pi 1.2.0 and pi-subagents 0.78.0.**
+  - With an OpenRouter key, `/model` lists only the models that key can use, with their real context sizes and prices.
+  - "The upstream provider returned an error" is retried instead of ending the turn, and Anthropic requests rejected for too many strict tools are retried once.
+  - `feynman -p` warns and exits 1 when the answer was cut off at the model's output limit.
+  - On Windows, reading or writing saved logins no longer fails with `EPERM` while an old lock is cleaned up.
+  - Pressing `Esc` keeps a research run stopped; a subagent finishing a moment later no longer restarts it.
+  - Reports are no longer overwritten when a subagent run is resumed, and a timed-out subagent's partial output reaches the lead agent.
+  - The `workflowScript contains dynamic child launches` warning no longer prints on every parallel run.
+- **`feynman model login` offers every provider Pi supports with an API key.** That is 41 providers instead of Feynman's own list of 16, adding DeepSeek, Fireworks, Together, NVIDIA, Google Vertex, Cloudflare, Qwen and others. Pi now asks for what each provider needs, so Cloudflare's extra fields and Bedrock's profile or bearer-token options work. Pressing Enter on an empty key no longer saves an empty credential.
+- **Turning off Feynman's telemetry also turns off Pi's.** `FEYNMAN_TELEMETRY=off` (or `DO_NOT_TRACK=1`) now sets Pi's own `PI_TELEMETRY=0` for its install reporting.
+- Feynman now honors Pi's own `sessionDir` setting and `PI_CODING_AGENT_SESSION_DIR` when you don't pass `--session-dir`.
+- `feynman model set` and the default-model check use Pi's settings API, so they match what Pi launches with (including trusted project settings).
+
+## v0.5.41 - 2026-10-12
+
+- **A fresh `npm install` works again.** Pi 1.2.0, released today, made new npm installs of Feynman 0.5.40 fail on every command except `-v` (`does not provide an export named 'MCP_TYPESCRIPT_PREAMBLE'`). Pi 1.1.0 asks for its own sub-packages with open version ranges, so npm pulled Pi 1.2.0's copies. Feynman now pins those sub-packages to the Pi version it ships. The curl and PowerShell installers were not affected.
+- **An expired sign-in no longer looks like no model.** Feynman treated a ChatGPT, Claude or Copilot sign-in whose short-lived access token had expired as if no model were set up. `feynman` reopened the setup menu, and since 0.5.36 `feynman -p` refused to run. Pi renews the token on the next request, so Feynman now leaves that to Pi and asks you to sign in again only when renewal really fails.
+- **`--model` accepts the names Pi accepts.** Bare model IDs (`claude-opus-5-5`), short names (`sonnet`) and a thinking suffix (`anthropic/claude-opus-5-5:high`) now work, preferring a provider you are signed in to; `provider/model` and `provider:model` still work. Pro-class models stay blocked.
+- **After you sign in, the model list matches your account.** `feynman model login` refreshes that provider's model list, so an OpenRouter key gets the models it can actually use before Feynman picks a default.
+- A provider error hint now appears once the run has stopped, not in the middle of an automatic retry.
+- Launching Feynman no longer erases your terminal's scrollback.
+- The llama.cpp provider is recognized as a local model.
+- **Preview and PDF export find more browsers.** Chromium, Edge and Brave on Linux, Edge under `Program Files (x86)` and Brave in your user folder on Windows, and apps in `~/Applications` on macOS. Thanks to @A-ryanVAT-S (#343).
+
 ## v0.5.40 - 2026-10-12
 
 - **alphaXiv sign-in messages name the right command.** When you weren't signed in, `feynman alpha search`, `get` and the paper tools said to run `alpha login`, a command that isn't installed with Feynman. They now say `feynman alpha login`. (Alpha Hub 0.1.7.)

package/dist/cli.js

@@ -19,7 +19,7 @@ import { ensureFeynmanAgentDir } from "./bootstrap/home.js";
 import { ensureFeynmanHome, getDefaultSessionDir, getFeynmanAgentDir, getFeynmanHome } from "./config/paths.js";
 import { getLastPiStderr, launchPiChat, runPi } from "./pi/launch.js";
 import { installPiPackage, removePiPackage, listOptionalPackagePresets, normalizeOptionalPackagePresetName, resolvePackageSource, updatePiPackages, } from "./pi/packages.js";
-import { canonicalizeModelSpec, ensureFeynmanSettings, normalizeThinkingLevel, readJson, } from "./pi/settings.js";
+import { resolveExplicitModelSpec, ensureFeynmanSettings, normalizeThinkingLevel, readJson, } from "./pi/settings.js";
 import { BUNDLED_PI_PACKAGES, buildPiEnv, findWindowsBash, WINDOWS_BASH_MISSING_NOTICE } from "./pi/runtime.js";
 import { getConfiguredServiceTier, normalizeServiceTier, setConfiguredServiceTier } from "./model/service-tier.js";
 import { authenticateModelProvider, getCurrentModelSpec, isLocalModelProvider, loginModelProvider, logoutModelProvider, printModelList, selectDefaultModel, setDefaultModelSpec, } from "./model/commands.js";
@@ -29,6 +29,7 @@ import { fetchLatestFeynmanVersion, getFeynmanUpgradeLines, isNewerVersion } fro
 import { runDoctor, runStatus } from "./setup/doctor.js";
 import { setupPreviewDependencies } from "./setup/preview.js";
 import { runSetup } from "./setup/setup.js";
+import { SettingsManager } from "@earendil-works/pi-coding-agent";
 import { noModelMessage } from "./setup/prompts.js";
 import { captureTelemetryEvent, captureTelemetryException, getCliTelemetryMetadata, initializePostHogTelemetry, shutdownPostHogTelemetry, telemetryErrorProperties, telemetryFirstRunNotice, } from "./telemetry/posthog.js";
 import { ASH, printAsciiHeader, printInfo, printPanel, printSection, RESET, SAGE } from "./ui/terminal.js";
@@ -421,7 +422,9 @@ export async function main() {
             ...commandTelemetry,
             duration_ms: durationMs,
             exit_code: exitCode,
-            ...(exitCode === 0 ? {} : { pi_stderr: getLastPiStderr() }),
+            // A fixed reason for a deliberate non-zero exit, so it isn't read as a crash.
+            ...(exitReason ? { exit_reason: exitReason } : {}),
+            ...(exitCode === 0 || exitReason ? {} : { pi_stderr: getLastPiStderr() }),
         };
         captureTelemetryEvent(exitCode === 0 ? "feynman_command_completed" : "feynman_command_failed", completeProperties);
     }
@@ -440,6 +443,8 @@ export async function main() {
         await shutdownPostHogTelemetry();
     }
 }
+// Set when Feynman exits non-zero on purpose (see the completion telemetry in main).
+let exitReason;
 async function runMain(input) {
     const { appRoot, feynmanVersion } = input;
     const bundledSettingsPath = resolve(appRoot, ".feynman", "settings.json");
@@ -512,7 +517,12 @@ async function runMain(input) {
         throw new Error("Unable to determine the installed Feynman version.");
     }
     const workingDir = resolve(values.cwd ?? process.cwd());
-    const sessionDir = resolve(values["session-dir"] ?? getDefaultSessionDir(feynmanHome));
+    // Pi's order: --session-dir, then PI_CODING_AGENT_SESSION_DIR, then the sessionDir
+    // setting; Feynman's own default comes last.
+    const sessionDir = resolve(workingDir, values["session-dir"] ??
+        process.env.PI_CODING_AGENT_SESSION_DIR ??
+        SettingsManager.create(workingDir, feynmanAgentDir).getSessionDir() ??
+        getDefaultSessionDir(feynmanHome));
     const feynmanSettingsPath = resolve(feynmanAgentDir, "settings.json");
     const feynmanAuthPath = resolve(feynmanAgentDir, "auth.json");
     const { defaultThinkingLevel, launchThinkingLevel } = resolveThinkingConfig(values.thinking ?? process.env.FEYNMAN_THINKING);
@@ -641,10 +651,14 @@ async function runMain(input) {
             throw new Error(`Pro-class model disabled: ${requestedExplicitModelSpec}. Choose an approved research model.`);
         }
         const modelRuntime = await createModelRuntime(feynmanAuthPath);
-        const canonicalModelSpec = canonicalizeModelSpec(requestedExplicitModelSpec, modelRuntime);
+        const canonicalModelSpec = resolveExplicitModelSpec(requestedExplicitModelSpec, modelRuntime);
         if (!canonicalModelSpec) {
             throw new Error(`Unknown model: ${requestedExplicitModelSpec}. Run \`feynman model list\` to see available models.`);
         }
+        // Check the resolved model too: a short name can resolve to a Pro-class one.
+        if (isProClassModelSpec(canonicalModelSpec.replace(/:(off|minimal|low|medium|high|xhigh|max)$/, ""))) {
+            throw new Error(`Pro-class model disabled: ${canonicalModelSpec}. Choose an approved research model.`);
+        }
         explicitModelSpec = canonicalModelSpec;
     }
     const workflowCommandNames = new Set(readPromptSpecs(appRoot).filter((s) => s.topLevelCli).map((s) => s.name));
@@ -666,6 +680,7 @@ async function runMain(input) {
         if (!getCurrentModelSpec(feynmanSettingsPath)) {
             console.error(noModelMessage(promptGiven));
             process.exitCode = 1;
+            exitReason = "no_model";
             return;
         }
         await ensureFeynmanSettings(feynmanSettingsPath, bundledSettingsPath, appRoot, defaultThinkingLevel, feynmanAuthPath);
@@ -674,6 +689,7 @@ async function runMain(input) {
         && (await getAuthenticatedModelRecords(feynmanAuthPath)).length === 0) {
         console.error(noModelMessage(promptGiven));
         process.exitCode = 1;
+        exitReason = "no_model";
         return;
     }
     // Pi's own session flags pass through; Feynman continues the latest

package/dist/model/catalog.js

@@ -1,5 +1,3 @@
-import { getEnvApiKey } from "@earendil-works/pi-ai/compat";
-import { readJsonFile } from "../config/json-file.js";
 import { createModelRuntime } from "./registry.js";
 const PRO_CLASS_MODEL_PATTERN = /(?:^|[-_.:/])pro(?:$|[-_.:/])/i;
 // Pi catalogs these exact DeepSeek V4 Pro model IDs as ordinary open-weight
@@ -329,10 +327,8 @@ function sortProviders(left, right) {
     return left.label.localeCompare(right.label);
 }
 export async function getAuthenticatedModelRecords(authPath) {
-    const expiredOAuthProviders = readExpiredOAuthProviders(authPath);
     const modelRuntime = await createModelRuntime(authPath);
     return (await modelRuntime.getAvailable())
-        .filter((model) => !expiredOAuthProviders.has(model.provider))
         .map((model) => ({ provider: model.provider, id: model.id, name: model.name }));
 }
 export async function getAvailableModelRecords(authPath) {
@@ -344,26 +340,6 @@ export async function getSupportedModelRecords(authPath) {
         .getModels()
         .map((model) => ({ provider: model.provider, id: model.id, name: model.name }));
 }
-function readExpiredOAuthProviders(authPath) {
-    const expired = new Set();
-    try {
-        const parsed = readJsonFile(authPath);
-        for (const [provider, credential] of Object.entries(parsed)) {
-            if (!credential || typeof credential !== "object")
-                continue;
-            const typedCredential = credential;
-            if (typedCredential.type !== "oauth" || typeof typedCredential.expires !== "number")
-                continue;
-            if (typedCredential.expires > Date.now())
-                continue;
-            if (getEnvApiKey(provider))
-                continue;
-            expired.add(provider);
-        }
-    }
-    catch { }
-    return expired;
-}
 export async function chooseRecommendedModel(authPath) {
     const preferred = choosePreferredModelRecord(await getAvailableModelRecords(authPath));
     if (!preferred) {

package/dist/model/commands.js

@@ -1,9 +1,8 @@
-import { readFileSync, writeFileSync } from "node:fs";
+import { SettingsManager } from "@earendil-works/pi-coding-agent";
+import { readFileSync } from "node:fs";
 import { exec as execCallback } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { dirname, resolve } from "node:path";
+import { dirname } from "node:path";
 import { promisify } from "node:util";
-import { readJson } from "../pi/settings.js";
 import { promptChoice, promptSecret, promptSelect, promptText, SetupCancelledError, validateApiKeyInput } from "../setup/prompts.js";
 import { openUrl } from "../system/open-url.js";
 import { printInfo, printSection, printSuccess, printWarning } from "../ui/terminal.js";
@@ -54,19 +53,32 @@ async function selectOAuthProvider(authPath, action) {
     }
     return selection;
 }
-function resolveApiKeyProvider(input) {
+// Endpoints Pi has no API-key sign-in for: Feynman writes their models.json entry.
+const LOCAL_API_KEY_SETUPS = MODEL_API_KEY_PROVIDERS.filter((provider) => ["lm-studio", "litellm", "__custom__"].includes(provider.id));
+// Every provider Pi can sign in to with an API key (its own list, labels and
+// prompts), plus Feynman's local and custom endpoint setups.
+export async function listApiKeyProviders(authPath) {
+    const envVars = new Map(MODEL_API_KEY_PROVIDERS.map((provider) => [provider.id, provider.envVar]));
+    const piProviders = (await createModelRuntime(authPath))
+        .getProviders()
+        .filter((provider) => provider.auth.apiKey)
+        .map((provider) => ({ id: provider.id, label: provider.name, envVar: envVars.get(provider.id) }))
+        .sort((left, right) => left.label.localeCompare(right.label));
+    return [...piProviders, ...LOCAL_API_KEY_SETUPS];
+}
+async function resolveApiKeyProvider(authPath, input) {
     const normalizedInput = normalizeProviderId(input);
     if (!normalizedInput) {
         return undefined;
     }
-    return MODEL_API_KEY_PROVIDERS.find((provider) => provider.id === normalizedInput);
+    return (await listApiKeyProviders(authPath)).find((provider) => provider.id === normalizedInput);
 }
 export async function resolveModelProviderForCommand(authPath, input) {
     const oauthProvider = await resolveOAuthProvider(authPath, input);
     if (oauthProvider) {
         return { kind: "oauth", id: oauthProvider.id };
     }
-    const apiKeyProvider = resolveApiKeyProvider(input);
+    const apiKeyProvider = await resolveApiKeyProvider(authPath, input);
     if (apiKeyProvider) {
         return { kind: "api-key", id: apiKeyProvider.id };
     }
@@ -84,14 +96,15 @@ function apiKeyProviderHint(provider) {
     }
     return provider.envVar ?? provider.id;
 }
-async function selectApiKeyProvider() {
-    const options = MODEL_API_KEY_PROVIDERS.map((provider) => ({
+async function selectApiKeyProvider(authPath) {
+    const providers = await listApiKeyProviders(authPath);
+    const options = providers.map((provider) => ({
         value: provider,
         label: provider.label,
         hint: apiKeyProviderHint(provider),
     }));
     options.push({ value: "cancel", label: "Cancel" });
-    const defaultProvider = MODEL_API_KEY_PROVIDERS.find((provider) => provider.id === "openai") ?? MODEL_API_KEY_PROVIDERS[0];
+    const defaultProvider = providers.find((provider) => provider.id === "openai") ?? providers[0];
     const selection = await promptSelect("Choose an API-key provider:", options, defaultProvider);
     if (selection === "cancel") {
         return undefined;
@@ -125,7 +138,8 @@ function normalizeCustomProviderBaseUrl(api, baseUrl) {
 function isLocalBaseUrl(baseUrl) {
     return /^(https?:\/\/)?(localhost|127\.0\.0\.1|0\.0\.0\.0)(:|\/|$)/i.test(baseUrl);
 }
-const LOCAL_PROVIDER_IDS = new Set(["ollama", "lm-studio", "vllm", "llama-cpp", "llamacpp"]);
+// "llama.cpp" is the id of Pi's bundled llama.cpp provider.
+const LOCAL_PROVIDER_IDS = new Set(["ollama", "lm-studio", "vllm", "llama.cpp", "llama-cpp", "llamacpp"]);
 export function isLocalModelProvider(authPath, providerId) {
     if (!providerId) {
         return false;
@@ -500,36 +514,6 @@ async function verifyCustomProvider(setup, authPath) {
     }
     printInfo("Verification: skipped network probe for this API mode.");
 }
-async function verifyBedrockCredentialChain() {
-    const { defaultProvider } = await import("@aws-sdk/credential-provider-node");
-    const credentials = await defaultProvider({})();
-    if (!credentials?.accessKeyId || !credentials?.secretAccessKey) {
-        throw new Error("AWS credential chain resolved without usable Bedrock credentials.");
-    }
-}
-async function configureBedrockProvider(authPath) {
-    printSection("AWS Credentials: Amazon Bedrock");
-    printInfo("Feynman will verify the AWS SDK credential chain used by Pi's Bedrock provider.");
-    printInfo("Supported sources include AWS_PROFILE, ~/.aws credentials/config, SSO, ECS/IRSA, and EC2 instance roles.");
-    try {
-        await verifyBedrockCredentialChain();
-        const modelRuntime = await createModelRuntime(authPath);
-        if (!(await modelRuntime.checkAuth("amazon-bedrock"))) {
-            throw new Error("Pi could not resolve the verified AWS credential chain for Amazon Bedrock.");
-        }
-        printSuccess("Verified the AWS credential chain used by Amazon Bedrock.");
-        printInfo("Use `feynman model list` to see available Bedrock models.");
-        return true;
-    }
-    catch (error) {
-        printWarning(`AWS credential verification failed: ${error instanceof Error ? error.message : String(error)}`);
-        printInfo("Configure AWS credentials first, for example:");
-        printInfo("  export AWS_PROFILE=default");
-        printInfo("  # or set AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY");
-        printInfo("  # or use an EC2/ECS/IRSA role with valid Bedrock access");
-        return false;
-    }
-}
 async function maybeSetRecommendedDefaultModel(settingsPath, authPath) {
     if (!settingsPath) {
         return;
@@ -545,7 +529,7 @@ async function maybeSetRecommendedDefaultModel(settingsPath, authPath) {
     }
 }
 async function configureApiKeyProvider(authPath, providerId) {
-    const provider = providerId ? resolveApiKeyProvider(providerId) : await selectApiKeyProvider();
+    const provider = providerId ? await resolveApiKeyProvider(authPath, providerId) : await selectApiKeyProvider(authPath);
     if (!provider) {
         if (providerId) {
             throw new Error(`Unknown API-key model provider: ${providerId}`);
@@ -553,9 +537,6 @@ async function configureApiKeyProvider(authPath, providerId) {
         printInfo("API key setup cancelled.");
         return false;
     }
-    if (provider.id === "amazon-bedrock") {
-        return configureBedrockProvider(authPath);
-    }
     if (provider.id === "lm-studio") {
         const setup = await promptLmStudioProviderSetup();
         if (!setup) {
@@ -626,22 +607,34 @@ async function configureApiKeyProvider(authPath, providerId) {
     if (provider.envVar) {
         printInfo(`Tip: to avoid writing secrets to disk, set ${provider.envVar} in your shell or .env.`);
     }
-    const apiKey = await promptSecret("Paste API key (leave empty to use env var instead)", undefined, validateApiKeyInput);
-    if (!apiKey) {
-        if (provider.envVar) {
-            printInfo(`Set ${provider.envVar} and rerun setup (or run \`feynman model list\`).`);
-        }
-        else {
-            printInfo("No API key provided.");
-        }
-        return false;
-    }
+    // Pi asks for whatever this provider needs (a key, or e.g. Cloudflare's account
+    // and gateway, Bedrock's profile or token). Esc cancels.
     const modelRuntime = await createModelRuntime(authPath);
-    await modelRuntime.login(provider.id, "api_key", {
-        prompt: async () => apiKey,
-        notify: () => undefined,
+    const interaction = terminalAuthInteraction(provider.label, new AbortController().signal);
+    const signedIn = await modelRuntime
+        .login(provider.id, "api_key", {
+        ...interaction,
+        prompt: async (prompt) => {
+            if (prompt.type !== "secret")
+                return interaction.prompt(prompt);
+            const secret = await promptSecret(prompt.message, prompt.signal, validateApiKeyInput);
+            // An empty key would be saved as a credential that fails every request.
+            if (!secret)
+                throw new SetupCancelledError("no API key entered");
+            return secret;
+        },
+    })
+        .then(() => true)
+        .catch((error) => {
+        if (!(error instanceof SetupCancelledError))
+            throw error;
+        if (provider.envVar)
+            printInfo(`Or set ${provider.envVar} and run feynman again.`);
+        return false;
     });
-    printSuccess(`Saved API key for ${provider.id} in auth storage.`);
+    if (!signedIn)
+        return false;
+    printSuccess(`Saved ${provider.label} credentials in auth storage.`);
     const baseUrl = await promptText("Base URL override (optional, include /v1 for OpenAI-compatible endpoints)", "");
     if (baseUrl) {
         const modelsJsonPath = getModelsJsonPath(authPath);
@@ -653,6 +646,7 @@ async function configureApiKeyProvider(authPath, providerId) {
             printWarning(result.error);
         }
     }
+    await refreshProviderModels(modelRuntime, provider.id);
     return true;
 }
 async function resolveAvailableModelSpec(authPath, input) {
@@ -672,8 +666,8 @@ async function resolveAvailableModelSpec(authPath, input) {
     // When multiple providers expose the same bare model ID, prefer providers the
     // user explicitly configured in auth storage.
     if (exactIdMatches.length > 1) {
-        const authData = readJson(authPath);
-        const configuredProviders = new Set(Object.keys(authData));
+        const credentials = await (await createModelRuntime(authPath)).listCredentials();
+        const configuredProviders = new Set(credentials.map((credential) => credential.providerId));
         const configuredMatches = exactIdMatches.filter((model) => configuredProviders.has(model.provider));
         if (configuredMatches.length === 1) {
             return `${configuredMatches[0].provider}/${configuredMatches[0].id}`;
@@ -681,12 +675,12 @@ async function resolveAvailableModelSpec(authPath, input) {
     }
     return undefined;
 }
+// The default model Pi will launch with, read through Pi's SettingsManager.
 export function getCurrentModelSpec(settingsPath) {
-    const settings = readJson(settingsPath);
-    if (typeof settings.defaultProvider === "string" && typeof settings.defaultModel === "string") {
-        return `${settings.defaultProvider}/${settings.defaultModel}`;
-    }
-    return undefined;
+    const settings = SettingsManager.create(process.cwd(), dirname(settingsPath));
+    const provider = settings.getDefaultProvider();
+    const model = settings.getDefaultModel();
+    return provider && model ? `${provider}/${model}` : undefined;
 }
 export async function printModelList(settingsPath, authPath) {
     const status = await collectModelStatus(settingsPath, authPath);
@@ -733,13 +727,11 @@ export async function authenticateModelProvider(authPath, settingsPath) {
 }
 // Sign in with ChatGPT sends a stable installation ID. Pi's own /login keeps it
 // as `deviceId` in the agent settings.json; share that one.
-export function getOrCreateDeviceId(authPath) {
-    const settingsPath = resolve(dirname(authPath), "settings.json");
-    const settings = readJson(settingsPath);
-    if (typeof settings.deviceId === "string" && settings.deviceId)
-        return settings.deviceId;
-    const deviceId = randomUUID();
-    writeFileSync(settingsPath, `${JSON.stringify({ ...settings, deviceId }, null, 2)}\n`, "utf8");
+// Pi's own device ID, the one its /login sends, kept in the agent settings.
+export async function getOrCreateDeviceId(authPath) {
+    const settings = SettingsManager.create(process.cwd(), dirname(authPath));
+    const deviceId = settings.getOrCreateDeviceId();
+    await settings.flush();
     return deviceId;
 }
 // A provider answers invalid_grant when it rejects the authorization code, and
@@ -752,31 +744,15 @@ export function describeOAuthLoginFailure(providerId, error) {
     const alternative = providerId === "openai" ? " Or sign in with `feynman model login openai-codex` instead." : "";
     return new Error(`${error.message}\nThe sign-in was rejected, usually because of a stale browser session. Sign out of the provider's site in your browser, or use a private window, then run \`feynman model login ${providerId}\` again.${alternative}`);
 }
-export async function loginModelProvider(authPath, providerId, settingsPath) {
-    if (providerId) {
-        const resolvedProvider = await resolveModelProviderForCommand(authPath, providerId);
-        if (!resolvedProvider) {
-            throw new Error(`Unknown model provider: ${providerId}`);
-        }
-        if (resolvedProvider.kind === "api-key") {
-            const configured = await configureApiKeyProvider(authPath, resolvedProvider.id);
-            if (configured) {
-                await maybeSetRecommendedDefaultModel(settingsPath, authPath);
-            }
-            return configured;
-        }
-    }
-    const provider = providerId ? await resolveOAuthProvider(authPath, providerId) : await selectOAuthProvider(authPath, "login");
-    if (!provider) {
-        if (providerId) {
-            throw new Error(`Unknown model provider: ${providerId}`);
-        }
-        printInfo("Login cancelled.");
-        return false;
-    }
-    const modelRuntime = await createModelRuntime(authPath);
-    const abortController = new AbortController();
-    await modelRuntime.login(provider.id, "oauth", {
+// Pi's /login refreshes the provider's model list from the network after
+// signing in (OpenRouter keys get the models that key may use); do the same,
+// so the recommended default comes from that list. A failure keeps the saved list.
+async function refreshProviderModels(modelRuntime, providerId) {
+    await modelRuntime.refresh({ providers: [providerId], allowNetwork: true, signal: AbortSignal.timeout(15_000) }).catch(() => undefined);
+}
+// Runs Pi's own login prompts (selects, secrets, text, browser URLs) in the terminal.
+function terminalAuthInteraction(providerLabel, signal) {
+    return {
         prompt: async (prompt) => {
             if (prompt.type === "select") {
                 return promptSelect(prompt.message, prompt.options.map((option) => ({
@@ -795,7 +771,7 @@ export async function loginModelProvider(authPath, providerId, settingsPath) {
         },
         notify: (event) => {
             if (event.type === "auth_url") {
-                printSection(`Login: ${provider.name ?? provider.id}`);
+                printSection(`Login: ${providerLabel}`);
                 if (openUrl(event.url)) {
                     printInfo("Opened the login URL in your browser.");
                 }
@@ -809,7 +785,7 @@ export async function loginModelProvider(authPath, providerId, settingsPath) {
                 return;
             }
             if (event.type === "device_code") {
-                printSection(`Login: ${provider.name ?? provider.id}`);
+                printSection(`Login: ${providerLabel}`);
                 printInfo(`Visit ${event.verificationUri} and enter code: ${event.userCode}`);
                 openUrl(event.verificationUri);
                 return;
@@ -818,11 +794,39 @@ export async function loginModelProvider(authPath, providerId, settingsPath) {
                 printInfo(event.message);
             }
         },
-        signal: abortController.signal,
-    }, { getDeviceId: () => getOrCreateDeviceId(authPath) }).catch((error) => {
+        signal,
+    };
+}
+export async function loginModelProvider(authPath, providerId, settingsPath) {
+    if (providerId) {
+        const resolvedProvider = await resolveModelProviderForCommand(authPath, providerId);
+        if (!resolvedProvider) {
+            throw new Error(`Unknown model provider: ${providerId}`);
+        }
+        if (resolvedProvider.kind === "api-key") {
+            const configured = await configureApiKeyProvider(authPath, resolvedProvider.id);
+            if (configured) {
+                await maybeSetRecommendedDefaultModel(settingsPath, authPath);
+            }
+            return configured;
+        }
+    }
+    const provider = providerId ? await resolveOAuthProvider(authPath, providerId) : await selectOAuthProvider(authPath, "login");
+    if (!provider) {
+        if (providerId) {
+            throw new Error(`Unknown model provider: ${providerId}`);
+        }
+        printInfo("Login cancelled.");
+        return false;
+    }
+    const modelRuntime = await createModelRuntime(authPath);
+    const abortController = new AbortController();
+    const deviceId = await getOrCreateDeviceId(authPath);
+    await modelRuntime.login(provider.id, "oauth", terminalAuthInteraction(provider.name ?? provider.id, abortController.signal), { getDeviceId: () => deviceId }).catch((error) => {
         throw describeOAuthLoginFailure(provider.id, error);
     });
     printSuccess(`Model provider login complete: ${provider.id}`);
+    await refreshProviderModels(modelRuntime, provider.id);
     await maybeSetRecommendedDefaultModel(settingsPath, authPath);
     return true;
 }
@@ -880,11 +884,10 @@ export async function setDefaultModelSpec(settingsPath, authPath, spec) {
         throw new Error(await describeUnavailableModelSpec(authPath, spec));
     }
     const [provider, ...rest] = resolvedSpec.split("/");
-    const modelId = rest.join("/");
-    const settings = readJson(settingsPath);
-    settings.defaultProvider = provider;
-    settings.defaultModel = modelId;
-    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+    // Pi's SettingsManager merges only the changed keys under its lock.
+    const settings = SettingsManager.create(process.cwd(), dirname(settingsPath));
+    settings.setDefaultModelAndProvider(provider, rest.join("/"));
+    await settings.flush();
     printSuccess(`Research default model set to ${resolvedSpec}`);
 }
 export async function selectDefaultModel(settingsPath, authPath) {

package/dist/pi/launch.js

@@ -42,8 +42,9 @@ export async function runPi(options, args, env, stdin = "inherit") {
 }
 export async function launchPiChat(options) {
     let telemetryNotice;
+    // No screen clear: Pi's fullscreen mode uses the alternate screen, and
+    // `--tui-mode regular` keeps the terminal's scrollback.
     if (process.stdout.isTTY && options.mode !== "rpc") {
-        process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
         telemetryNotice = telemetryFirstRunNotice();
     }
     const executables = await resolveAllExecutables();

package/dist/pi/runtime.js

@@ -1,8 +1,8 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { delimiter, dirname, resolve, win32 } from "node:path";
-import { BROWSER_FALLBACK_PATHS, MERMAID_FALLBACK_PATHS, PANDOC_FALLBACK_PATHS, resolveExecutable, } from "../system/executables.js";
-import { getPostHogChildEnv } from "../telemetry/posthog.js";
+import { MERMAID_FALLBACK_PATHS, PANDOC_FALLBACK_PATHS, resolveBrowser, resolveExecutable, } from "../system/executables.js";
+import { getPostHogChildEnv, isTelemetryDisabled } from "../telemetry/posthog.js";
 // Pi packages shipped as Feynman dependencies and loaded from their install
 // paths through settings.json `packages` (Pi's documented local-path source).
 export const BUNDLED_PI_PACKAGES = ["pi-subagents", "pi-web-access", "pi-docparser", "pi-btw"];
@@ -145,7 +145,7 @@ export function buildPiEnv(options, executables) {
     const binPath = [getFeynmanCommandShimDir(options.feynmanAgentDir), resolve(options.appRoot, "node_modules", ".bin")].join(delimiter);
     const pandocPath = process.env.PANDOC_PATH ?? executables?.pandoc ?? resolveExecutable("pandoc", PANDOC_FALLBACK_PATHS);
     const mermaidPath = process.env.MERMAID_CLI_PATH ?? executables?.mermaid ?? resolveExecutable("mmdc", MERMAID_FALLBACK_PATHS);
-    const browserPath = process.env.PUPPETEER_EXECUTABLE_PATH ?? executables?.browser ?? resolveExecutable("google-chrome", BROWSER_FALLBACK_PATHS);
+    const browserPath = process.env.PUPPETEER_EXECUTABLE_PATH ?? executables?.browser ?? resolveBrowser();
     return {
         ...process.env,
         PATH: [binPath, process.env.PATH ?? "", process.platform === "win32" ? findWindowsBash()?.addDir : undefined]
@@ -156,8 +156,9 @@ export function buildPiEnv(options, executables) {
         FEYNMAN_BIN_PATH: getFeynmanCliBinPath(options.appRoot),
         PI_CODING_AGENT_DIR: options.feynmanAgentDir,
         PANDOC_PATH: pandocPath,
-        PI_HARDWARE_CURSOR: process.env.PI_HARDWARE_CURSOR ?? "1",
         PI_SKIP_VERSION_CHECK: process.env.PI_SKIP_VERSION_CHECK ?? "1",
+        // A Feynman telemetry opt-out also turns off Pi's install telemetry (docs/environment-variables.md).
+        ...(isTelemetryDisabled() && process.env.PI_TELEMETRY === undefined ? { PI_TELEMETRY: "0" } : {}),
         MERMAID_CLI_PATH: mermaidPath,
         PUPPETEER_EXECUTABLE_PATH: browserPath,
         ...getPostHogChildEnv(),

package/dist/pi/settings.js

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { resolveCliModel } from "@earendil-works/pi-coding-agent";
 import { parseJsonText, readJsonFile } from "../config/json-file.js";
 import { BUNDLED_PI_PACKAGES, getFeynmanPackageSources, resolvePackageRoot } from "./runtime.js";
 import { choosePreferredModelRecord, getAvailableModelRecords } from "../model/catalog.js";
@@ -32,6 +33,29 @@ export function canonicalizeModelSpec(spec, modelLookup) {
     const model = parseModelSpec(spec, modelLookup);
     return model ? `${model.provider}/${model.id}` : undefined;
 }
+// `--model` input, resolved the way Pi resolves it (bare ids, fuzzy names, a
+// `:<thinking>` suffix) after Feynman's exact provider/id and provider:id
+// forms. Pi's fuzzy match ignores sign-ins, so the same model id on a provider
+// you are signed in to wins.
+export function resolveExplicitModelSpec(spec, modelRuntime) {
+    const exact = canonicalizeModelSpec(spec, modelRuntime);
+    if (exact)
+        return exact;
+    let result = resolveCliModel({ cliModel: spec.trim(), modelRuntime });
+    if (!result.model)
+        return undefined;
+    if (!modelRuntime.hasConfiguredAuth(result.model.provider)) {
+        for (const provider of new Set(modelRuntime.getAvailableSnapshot().map((model) => model.provider))) {
+            const signedIn = resolveCliModel({ cliProvider: provider, cliModel: spec.trim(), modelRuntime });
+            if (signedIn.model && !signedIn.warning) {
+                result = signedIn;
+                break;
+            }
+        }
+    }
+    const model = result.model;
+    return `${model.provider}/${model.id}${result.thinkingLevel ? `:${result.thinkingLevel}` : ""}`;
+}
 export function normalizeThinkingLevel(value) {
     if (!value) {
         return undefined;

package/dist/setup/doctor.js

@@ -3,7 +3,7 @@ import { getValidToken as getValidAlphaToken } from "@companion-ai/alpha-hub/lib
 import { readFileSync } from "node:fs";
 import { verifyAlphaAuthStatus } from "../alpha-auth-status.js";
 import { formatPiWebAccessDoctorLines, getPiWebAccessStatus } from "../pi/web-access.js";
-import { BROWSER_FALLBACK_PATHS, PANDOC_FALLBACK_PATHS, resolveExecutable } from "../system/executables.js";
+import { PANDOC_FALLBACK_PATHS, resolveBrowser, resolveExecutable } from "../system/executables.js";
 import { readJson } from "../pi/settings.js";
 import { findWindowsBash, validatePiInstallation, WINDOWS_BASH_MISSING_NOTICE } from "../pi/runtime.js";
 import { isTelemetryDisabled } from "../telemetry/posthog.js";
@@ -41,7 +41,7 @@ function findProvidersMissingApiKey(modelsJsonPath) {
 }
 export async function collectStatusSnapshot(options) {
     const pandocPath = resolveExecutable("pandoc", PANDOC_FALLBACK_PATHS);
-    const browserPath = process.env.PUPPETEER_EXECUTABLE_PATH ?? resolveExecutable("google-chrome", BROWSER_FALLBACK_PATHS);
+    const browserPath = process.env.PUPPETEER_EXECUTABLE_PATH ?? resolveBrowser();
     const missingPiBits = validatePiInstallation(options.appRoot);
     const webStatus = getPiWebAccessStatus();
     const modelStatus = buildModelStatusSnapshotFromRecords(await getSupportedModelRecords(options.authPath), await getAvailableModelRecords(options.authPath), getCurrentModelSpec(options.settingsPath));
@@ -105,7 +105,7 @@ export async function runDoctor(options) {
     const supportedModels = await getSupportedModelRecords(options.authPath);
     const modelStatus = await collectStatusSnapshot(options);
     const pandocPath = resolveExecutable("pandoc", PANDOC_FALLBACK_PATHS);
-    const browserPath = process.env.PUPPETEER_EXECUTABLE_PATH ?? resolveExecutable("google-chrome", BROWSER_FALLBACK_PATHS);
+    const browserPath = process.env.PUPPETEER_EXECUTABLE_PATH ?? resolveBrowser();
     const missingPiBits = validatePiInstallation(options.appRoot);
     printPanel("Feynman Doctor", [
         "Checks config, auth, runtime wiring, and preview dependencies.",

package/dist/system/executables.js

@@ -1,7 +1,9 @@
 import { execFile, spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
+import { homedir } from "node:os";
 import { dirname, delimiter } from "node:path";
 const isWindows = process.platform === "win32";
+const isLinux = process.platform === "linux";
 const programFiles = process.env.PROGRAMFILES ?? "C:\\Program Files";
 const localAppData = process.env.LOCALAPPDATA ?? "";
 export const PANDOC_FALLBACK_PATHS = isWindows
@@ -16,14 +18,35 @@ export const BROWSER_FALLBACK_PATHS = isWindows
         `${programFiles} (x86)\\Google\\Chrome\\Application\\chrome.exe`,
         `${localAppData}\\Google\\Chrome\\Application\\chrome.exe`,
         `${programFiles}\\Microsoft\\Edge\\Application\\msedge.exe`,
+        `${programFiles} (x86)\\Microsoft\\Edge\\Application\\msedge.exe`,
         `${programFiles}\\BraveSoftware\\Brave-Browser\\Application\\brave.exe`,
+        `${localAppData}\\BraveSoftware\\Brave-Browser\\Application\\brave.exe`,
     ]
-    : [
-        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
-        "/Applications/Chromium.app/Contents/MacOS/Chromium",
-        "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
-        "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
-    ];
+    : isLinux
+        ? [
+            "/usr/bin/google-chrome",
+            "/usr/bin/google-chrome-stable",
+            "/usr/bin/chromium",
+            "/usr/bin/chromium-browser",
+            "/snap/bin/chromium",
+            "/usr/bin/microsoft-edge",
+            "/usr/bin/brave-browser",
+            "/opt/google/chrome/chrome",
+        ]
+        : ["/Applications", `${homedir()}/Applications`].flatMap((dir) => [
+            `${dir}/Google Chrome.app/Contents/MacOS/Google Chrome`,
+            `${dir}/Chromium.app/Contents/MacOS/Chromium`,
+            `${dir}/Brave Browser.app/Contents/MacOS/Brave Browser`,
+            `${dir}/Microsoft Edge.app/Contents/MacOS/Microsoft Edge`,
+        ]);
+export const BROWSER_COMMANDS = [
+    "google-chrome",
+    "google-chrome-stable",
+    "chromium",
+    "chromium-browser",
+    "microsoft-edge",
+    "brave-browser",
+];
 export const MERMAID_FALLBACK_PATHS = isWindows
     ? []
     : ["/opt/homebrew/bin/mmdc", "/usr/local/bin/mmdc"];
@@ -81,11 +104,32 @@ export async function resolveExecutableAsync(name, fallbackPaths = []) {
         });
     });
 }
+export function resolveBrowser({ fallbackPaths = BROWSER_FALLBACK_PATHS, fileExists = existsSync, resolveCommand = (name) => resolveExecutable(name), } = {}) {
+    const fallback = fallbackPaths.find((candidate) => fileExists(candidate));
+    if (fallback) {
+        return fallback;
+    }
+    for (const name of BROWSER_COMMANDS) {
+        const resolved = resolveCommand(name);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    return undefined;
+}
+export async function resolveBrowserAsync() {
+    const fallback = findInFallbackPaths(BROWSER_FALLBACK_PATHS);
+    if (fallback) {
+        return fallback;
+    }
+    const resolved = await Promise.all(BROWSER_COMMANDS.map((name) => resolveExecutableAsync(name)));
+    return resolved.find(Boolean);
+}
 export async function resolveAllExecutables() {
     const [pandoc, mermaid, browser] = await Promise.all([
         resolveExecutableAsync("pandoc", PANDOC_FALLBACK_PATHS),
         resolveExecutableAsync("mmdc", MERMAID_FALLBACK_PATHS),
-        resolveExecutableAsync("google-chrome", BROWSER_FALLBACK_PATHS),
+        resolveBrowserAsync(),
     ]);
     return { pandoc, mermaid, browser };
 }

package/extensions/research-tools/model-error-hint.ts

@@ -1,3 +1,4 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 // Most failed research runs end on a provider error (quota, a key, a model the
@@ -24,9 +25,18 @@ export function modelErrorHint(provider: string, error: string): string | undefi
 }
 
 export function registerModelErrorHint(pi: ExtensionAPI): void {
-	pi.on("message_end", (event, ctx) => {
+	// Pi retries rate limits and outages itself; hint only about the error the
+	// run actually ended on, once it has settled.
+	let lastError: AssistantMessage | undefined;
+	pi.on("message_end", (event) => {
 		const message = event.message;
-		if (message.role !== "assistant" || message.stopReason !== "error" || !ctx.hasUI) return;
+		if (message.role !== "assistant") return;
+		lastError = message.stopReason === "error" ? message : undefined;
+	});
+	pi.on("agent_settled", (event, ctx) => {
+		const message = lastError;
+		lastError = undefined;
+		if (!message || event.aborted || !ctx.hasUI) return;
 		const hint = modelErrorHint(message.provider, message.errorMessage ?? "");
 		ctx.ui.notify(
 			`${hint ?? `${message.provider} returned an error.`} If this looks like a Feynman bug, report it at https://github.com/Companion-Inc/feynman/issues (Pi's /bug goes to Pi's developers).`,

package/extensions/research-tools/telemetry.ts

@@ -252,7 +252,8 @@ export function registerResearchTelemetry(
 			$ai_cache_creation_input_tokens: message.usage.cacheWrite,
 			// Pi reports input tokens with cache reads and writes already subtracted.
 			$ai_cache_reporting_exclusive: true,
-			$ai_latency: requestStartedAt === undefined ? undefined : (now() - requestStartedAt) / 1000,
+			// Pi times each response itself; older messages may lack it.
+			$ai_latency: message.durationMs !== undefined ? message.durationMs / 1000 : requestStartedAt === undefined ? undefined : (now() - requestStartedAt) / 1000,
 			$ai_http_status: httpStatus,
 			$ai_is_error: message.stopReason === "error",
 			$ai_error: message.stopReason === "error" ? errorText(message.errorMessage) : undefined,
@@ -264,8 +265,8 @@ export function registerResearchTelemetry(
 		if (run) run.stopReason = message.stopReason;
 	});
 
-	pi.on("agent_settled", (_event, ctx) => {
-		finishRun(ctx.cwd, stopStatus(run?.stopReason));
+	pi.on("agent_settled", (event, ctx) => {
+		finishRun(ctx.cwd, event.aborted ? "aborted" : stopStatus(run?.stopReason));
 	});
 
 	pi.on("session_shutdown", async (event, ctx) => {

package/metadata/commands.mjs

@@ -151,7 +151,7 @@ export const legacyFlags = [
 	{ usage: "--alpha-login", description: "Sign in to alphaXiv and exit." },
 	{ usage: "--alpha-logout", description: "Clear alphaXiv auth and exit." },
 	{ usage: "--alpha-status", description: "Show alphaXiv auth status and exit." },
-	{ usage: "--model <provider/model|provider:model>", description: "Force a specific approved research model." },
+	{ usage: "--model <model>", description: "Force an approved research model: provider/model, a bare ID, or a short name; add :high etc. for thinking." },
 	{ usage: "--service-tier <tier>", description: "Override request service tier for this run." },
 	{ usage: "--thinking <level>", description: "Set thinking level: off | minimal | low | medium | high | xhigh | max." },
 	{ usage: "--cwd <path>", description: "Set the working directory for tools." },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@companion-ai/feynman",
-  "version": "0.5.40",
+  "version": "0.5.42",
   "description": "The open source AI research agent.",
   "license": "MIT",
   "type": "module",
@@ -79,16 +79,20 @@
   "dependencies": {
     "@clack/prompts": "^1.8.1",
     "@companion-ai/alpha-hub": "0.1.7",
+    "@earendil-works/pi-codemode": "1.2.0",
+    "@earendil-works/pi-mcp": "1.2.0",
+    "@earendil-works/pi-telemetry": "1.2.0",
     "fast-xml-parser": "5.11.1",
     "pi-btw": "0.8.0",
     "pi-docparser": "4.0.0",
-    "pi-subagents": "0.77.0",
+    "pi-subagents": "0.78.0",
     "pi-web-access": "0.39.0",
     "posthog-node": "^5.53.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "1.1.0",
-    "@earendil-works/pi-coding-agent": "1.1.0",
+    "@earendil-works/pi-agent-core": "1.2.0",
+    "@earendil-works/pi-ai": "1.2.0",
+    "@earendil-works/pi-coding-agent": "1.2.0",
     "@earendil-works/pi-tui": "*",
     "typebox": "*"
   },