@companion-ai/feynman 0.5.41 → 0.5.43

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,26 @@ GitHub release notes are generated from the matching `## vX.Y.Z` section in this
 
 ## Unreleased
 
+## v0.5.43 - 2026-10-13
+
+- **Feynman reads and writes Pi's configuration only through Pi.** Settings now go through Pi's settings manager, which locks the file and changes only the keys Feynman sets, so a change Pi or another Feynman window makes at the same moment is no longer overwritten. Model checks, local-model detection and `feynman doctor` read your models through Pi, so comments in `models.json`, a `baseUrl` set on one model, and a key saved with `feynman model login` count the same way they do when Feynman runs.
+- `feynman doctor` no longer warns about a custom provider whose key you saved with `feynman model login` rather than writing it into `models.json`.
+
+## 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.

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 { resolveExplicitModelSpec, ensureFeynmanSettings, normalizeThinkingLevel, readJson, } from "./pi/settings.js";
+import { resolveExplicitModelSpec, ensureFeynmanSettings, normalizeThinkingLevel, } 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";
@@ -254,7 +255,8 @@ async function handleUpdateCommand(piOptions, feynmanVersion, source) {
     }
 }
 async function handlePackagesCommand(subcommand, args, piOptions) {
-    const configuredSources = new Set((readJson(resolve(piOptions.feynmanAgentDir, "settings.json")).packages ?? [])
+    const configuredSources = new Set(SettingsManager.create(process.cwd(), piOptions.feynmanAgentDir, { projectTrusted: false })
+        .getPackages()
         .map((entry) => (typeof entry === "string" ? entry : entry.source)));
     if (!subcommand || subcommand === "list") {
         printPanel("Feynman Packages", [
@@ -516,7 +518,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);
@@ -705,13 +712,12 @@ async function runMain(input) {
     if (command && workflowCommandNames.has(command) && mode !== "rpc" && mode !== "json" && process.stdout.isTTY) {
         const effectiveSpec = explicitModelSpec ?? getCurrentModelSpec(feynmanSettingsPath);
         const providerId = effectiveSpec?.split("/")[0] ?? "";
-        if (effectiveSpec && isLocalModelProvider(feynmanAuthPath, providerId)) {
+        if (effectiveSpec && await isLocalModelProvider(feynmanAuthPath, providerId)) {
             preLaunchNotice = buildLocalModelWorkflowNotice(effectiveSpec, command);
         }
     }
     if (process.platform === "win32" && mode !== "rpc" && mode !== "json" && process.stdout.isTTY) {
-        const shellPath = readJson(feynmanSettingsPath).shellPath;
-        if (typeof shellPath !== "string" && !findWindowsBash()) {
+        if (!SettingsManager.create(workingDir, feynmanAgentDir, { projectTrusted: false }).getShellPath() && !findWindowsBash()) {
             preLaunchNotice = [preLaunchNotice, WINDOWS_BASH_MISSING_NOTICE].filter(Boolean).join("\n");
         }
     }

package/dist/model/commands.js

@@ -1,15 +1,13 @@
 import { SettingsManager } from "@earendil-works/pi-coding-agent";
-import { readFileSync, writeFileSync } from "node:fs";
 import { exec as execCallback } from "node:child_process";
 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";
 import { buildModelStatusSnapshotFromRecords, chooseRecommendedModel, getAuthenticatedModelRecords, getAvailableModelRecords, getSupportedModelRecords, isProClassModelSpec, } from "./catalog.js";
 import { MODEL_API_KEY_PROVIDERS } from "./api-key-providers.js";
-import { createModelRegistry, createModelRuntime, getModelsJsonPath } from "./registry.js";
+import { createModelRuntime, getModelsJsonPath } from "./registry.js";
 import { apiKeyReference, upsertProviderBaseUrl, upsertProviderConfig } from "./models-json.js";
 const exec = promisify(execCallback);
 async function collectModelStatus(settingsPath, authPath) {
@@ -54,19 +52,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 +95,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;
@@ -127,22 +139,18 @@ function isLocalBaseUrl(baseUrl) {
 }
 // "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) {
+// Reads models.json through Pi, so its comments, BOM handling, and per-model
+// baseUrl overrides count the same way they do at launch.
+export async function isLocalModelProvider(authPath, providerId) {
     if (!providerId) {
         return false;
     }
     if (LOCAL_PROVIDER_IDS.has(providerId)) {
         return true;
     }
-    try {
-        const raw = readFileSync(getModelsJsonPath(authPath), "utf8");
-        const parsed = JSON.parse(raw);
-        const provider = parsed.providers?.[providerId];
-        return typeof provider?.baseUrl === "string" && isLocalBaseUrl(provider.baseUrl);
-    }
-    catch {
-        return false;
-    }
+    const modelRuntime = await createModelRuntime(authPath);
+    return [modelRuntime.getProvider(providerId)?.baseUrl, ...modelRuntime.getModels(providerId).map((model) => model.baseUrl)]
+        .some((baseUrl) => typeof baseUrl === "string" && isLocalBaseUrl(baseUrl));
 }
 async function resolveApiKeyConfig(apiKeyConfig) {
     const trimmed = apiKeyConfig.trim();
@@ -381,8 +389,8 @@ async function promptLiteLlmProviderSetup() {
     };
 }
 async function verifyCustomProvider(setup, authPath) {
-    const registry = await createModelRegistry(authPath);
-    const modelsError = registry.getError();
+    const modelRuntime = await createModelRuntime(authPath);
+    const modelsError = modelRuntime.getError();
     if (modelsError) {
         printWarning("Verification: models.json failed to load.");
         for (const line of modelsError.split("\n")) {
@@ -390,19 +398,19 @@ async function verifyCustomProvider(setup, authPath) {
         }
         return;
     }
-    const all = registry.getAll();
-    const hasModel = setup.modelIds.some((id) => all.some((model) => model.provider === setup.providerId && model.id === id));
+    const all = modelRuntime.getModels(setup.providerId);
+    const hasModel = setup.modelIds.some((id) => all.some((model) => model.id === id));
     if (!hasModel) {
         printWarning("Verification: model registry does not contain the configured provider/model ids.");
         return;
     }
-    const available = registry.getAvailable();
-    const hasAvailable = setup.modelIds.some((id) => available.some((model) => model.provider === setup.providerId && model.id === id));
+    const available = await modelRuntime.getAvailable(setup.providerId);
+    const hasAvailable = setup.modelIds.some((id) => available.some((model) => model.id === id));
     if (!hasAvailable) {
         printWarning("Verification: provider is not considered authenticated/available.");
         return;
     }
-    const apiKey = await registry.getApiKeyForProvider(setup.providerId);
+    const apiKey = (await modelRuntime.getAuth(setup.providerId).catch(() => undefined))?.auth.apiKey;
     if (!apiKey) {
         printWarning("Verification: API key could not be resolved (check env var name / !command).");
         return;
@@ -501,36 +509,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;
@@ -546,7 +524,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}`);
@@ -554,9 +532,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) {
@@ -627,22 +602,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);
@@ -683,12 +670,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);
@@ -758,32 +745,9 @@ export function describeOAuthLoginFailure(providerId, error) {
 async function refreshProviderModels(modelRuntime, providerId) {
     await modelRuntime.refresh({ providers: [providerId], allowNetwork: true, signal: AbortSignal.timeout(15_000) }).catch(() => undefined);
 }
-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", {
+// 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) => ({
@@ -802,7 +766,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.");
                 }
@@ -816,7 +780,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;
@@ -825,8 +789,35 @@ export async function loginModelProvider(authPath, providerId, settingsPath) {
                 printInfo(event.message);
             }
         },
-        signal: abortController.signal,
-    }, { getDeviceId: () => deviceId }).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}`);
@@ -869,7 +860,7 @@ async function describeUnavailableModelSpec(authPath, spec) {
         if (isProClassModelSpec(knownSpec)) {
             return `Pro-class model disabled: ${knownSpec}. Choose an approved research model.`;
         }
-        if (isLocalModelProvider(authPath, known.provider)) {
+        if (await isLocalModelProvider(authPath, known.provider)) {
             return `${knownSpec} has no API key. Pi only lists a local provider when it has one: add "apiKey": "local" to the ${known.provider} provider in ${getModelsJsonPath(authPath)}.`;
         }
         return `${knownSpec} has no credentials. Run \`feynman model login ${known.provider}\` first.`;
@@ -888,11 +879,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/model/registry.js

@@ -1,5 +1,5 @@
 import { dirname, resolve } from "node:path";
-import { ModelRegistry, ModelRuntime } from "@earendil-works/pi-coding-agent";
+import { ModelRuntime } from "@earendil-works/pi-coding-agent";
 export function getModelsJsonPath(authPath) {
     return resolve(dirname(authPath), "models.json");
 }
@@ -10,6 +10,3 @@ export async function createModelRuntime(authPath) {
         allowModelNetwork: false,
     });
 }
-export async function createModelRegistry(authPath) {
-    return new ModelRegistry(await createModelRuntime(authPath));
-}

package/dist/model/service-tier.js

@@ -11,6 +11,7 @@ export const FEYNMAN_SERVICE_TIERS = [
 const SERVICE_TIER_SET = new Set(FEYNMAN_SERVICE_TIERS);
 const OPENAI_SERVICE_TIERS = new Set(["auto", "default", "flex", "priority"]);
 const ANTHROPIC_SERVICE_TIERS = new Set(["auto", "standard_only"]);
+// serviceTier is Feynman's key; Pi's SettingsManager has no getter or setter for it, so it is read and written directly.
 function readSettings(settingsPath) {
     try {
         return readJsonFile(settingsPath);

package/dist/pi/runtime.js

@@ -2,7 +2,7 @@ import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "n
 import { createRequire } from "node:module";
 import { delimiter, dirname, resolve, win32 } from "node:path";
 import { MERMAID_FALLBACK_PATHS, PANDOC_FALLBACK_PATHS, resolveBrowser, resolveExecutable, } from "../system/executables.js";
-import { getPostHogChildEnv } from "../telemetry/posthog.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"];
@@ -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,18 +1,13 @@
 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 { resolveCliModel, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { parseJsonText } from "../config/json-file.js";
 import { BUNDLED_PI_PACKAGES, getFeynmanPackageSources, resolvePackageRoot } from "./runtime.js";
 import { choosePreferredModelRecord, getAvailableModelRecords } from "../model/catalog.js";
 import { migrateBareEnvApiKeys } from "../model/models-json.js";
 import { getModelsJsonPath } from "../model/registry.js";
 // Written by Feynman <= 0.4.0 next to a subagent extension path it managed.
 const LEGACY_RESEARCHER_EXTENSION_MARKER = "_feynmanResearchToolsExtension";
-function findModel(modelLookup, provider, id) {
-    return "find" in modelLookup
-        ? modelLookup.find(provider, id)
-        : modelLookup.getModel(provider, id);
-}
 export function parseModelSpec(spec, modelLookup) {
     const trimmed = spec.trim();
     for (const separator of ["/", ":"]) {
@@ -22,7 +17,7 @@ export function parseModelSpec(spec, modelLookup) {
         }
         const provider = trimmed.slice(0, separatorIndex);
         const id = trimmed.slice(separatorIndex + 1);
-        const model = findModel(modelLookup, provider, id);
+        const model = modelLookup.getModel(provider, id);
         if (model) {
             return model;
         }
@@ -72,20 +67,6 @@ export function normalizeThinkingLevel(value) {
     }
     return undefined;
 }
-export function readJson(path) {
-    if (!existsSync(path)) {
-        return {};
-    }
-    try {
-        return readJsonFile(path);
-    }
-    catch (error) {
-        if (process.env.FEYNMAN_DEBUG === "1") {
-            process.stderr.write(`[feynman] warning: failed to parse ${path}, treating as empty (${error instanceof Error ? error.message : "unknown error"})\n`);
-        }
-        return {};
-    }
-}
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -208,19 +189,25 @@ export function feynmanSubagentExtensions(appRoot) {
 function isFeynmanSubagentExtension(path) {
     return typeof path === "string" && (/[\\/]extensions[\\/]research-tools\.ts$/.test(path) || /[\\/]pi-web-access$/.test(path));
 }
-export async function ensureFeynmanSettings(settingsPath, bundledSettingsPath, appRoot, defaultThinkingLevel, authPath) {
-    // Validate before model discovery or either settings write. Invalid custom
-    // configuration must not silently turn into an empty/default configuration.
-    const subagentDefaults = prepareSubagentDefaults(settingsPath);
-    const existing = existsSync(settingsPath) ? readConfigObject(settingsPath, "Feynman settings") : undefined;
-    const settings = existing ? { ...existing.value } : {};
-    const defaults = readConfigObject(bundledSettingsPath, "bundled Feynman settings").value;
-    migrateBareEnvApiKeys(getModelsJsonPath(authPath));
-    for (const [key, value] of Object.entries({ ...defaults, defaultThinkingLevel })) {
-        if (settings[key] === undefined)
+// Bundled defaults (.feynman/settings.json) and the thinking level, seeded
+// through Pi's SettingsManager setters.
+const PI_SETTING_SETTERS = {
+    theme: (settings, value) => settings.setTheme(value),
+    quietStartup: (settings, value) => settings.setQuietStartup(value),
+    collapseChangelog: (settings, value) => settings.setCollapseChangelog(value),
+    editorPaddingX: (settings, value) => settings.setEditorPaddingX(value),
+    showHardwareCursor: (settings, value) => settings.setShowHardwareCursor(value),
+    defaultThinkingLevel: (settings, value) => settings.setDefaultThinkingLevel(value),
+};
+// SettingsManager has no setter for `subagents` (pi-subagents' key), for deleting `retry`, or for a
+// bundled default outside PI_SETTING_SETTERS, so those are edited in the file directly.
+function updateSettingsWithoutPiSetter(settingsPath, appRoot, defaults) {
+    const existing = existsSync(settingsPath) ? readConfigObject(settingsPath, "Feynman settings").value : {};
+    const settings = structuredClone(existing);
+    for (const [key, value] of Object.entries(defaults)) {
+        if (!(key in PI_SETTING_SETTERS) && settings[key] === undefined)
             settings[key] = value;
     }
-    settings.packages = reconcileFeynmanPackages(settings.packages, appRoot);
     removeLegacyResearcherExtension(settings);
     // 0.5.0-0.5.5 seeded a 6-retry, 5s backoff that left a dead connection
     // retrying silently for over five minutes; drop that exact value for Pi's default.
@@ -238,11 +225,35 @@ export async function ensureFeynmanSettings(settingsPath, bundledSettingsPath, a
             settings.subagents.defaultSubagentOnlyExtensions = feynmanSubagentExtensions(appRoot);
         }
     }
-    if (!settings.defaultProvider || !settings.defaultModel) {
+    if (JSON.stringify(settings) === JSON.stringify(existing))
+        return;
+    mkdirSync(dirname(settingsPath), { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+}
+export async function ensureFeynmanSettings(settingsPath, bundledSettingsPath, appRoot, defaultThinkingLevel, authPath) {
+    // Validate before model discovery or either settings write. Invalid custom
+    // configuration must not silently turn into an empty/default configuration.
+    const subagentDefaults = prepareSubagentDefaults(settingsPath);
+    // Feynman's agent settings are global; an untrusted project's .pi/settings.json stays out.
+    const settings = SettingsManager.create(process.cwd(), dirname(settingsPath), { projectTrusted: false });
+    const loadError = settings.drainErrors().find((error) => error.scope === "global")?.error;
+    const current = settings.getGlobalSettings();
+    if (loadError || !isRecord(current)) {
+        throw new Error(`Invalid Feynman settings at ${settingsPath}: ${loadError?.message ?? "expected a JSON object"}. Fix the JSON or delete the file. The file was not changed.`);
+    }
+    const defaults = readConfigObject(bundledSettingsPath, "bundled Feynman settings").value;
+    migrateBareEnvApiKeys(getModelsJsonPath(authPath));
+    for (const [key, value] of Object.entries({ ...defaults, defaultThinkingLevel })) {
+        if (current[key] === undefined)
+            PI_SETTING_SETTERS[key]?.(settings, value);
+    }
+    const packages = reconcileFeynmanPackages(current.packages, appRoot);
+    if (JSON.stringify(packages) !== JSON.stringify(current.packages))
+        settings.setPackages(packages);
+    if (!settings.getDefaultProvider() || !settings.getDefaultModel()) {
         const preferredModel = choosePreferredModelRecord(await getAvailableModelRecords(authPath));
         if (preferredModel) {
-            settings.defaultProvider = preferredModel.provider;
-            settings.defaultModel = preferredModel.id;
+            settings.setDefaultModelAndProvider(preferredModel.provider, preferredModel.id);
         }
     }
     // If another process wrote the subagent config while models were being
@@ -260,9 +271,11 @@ export async function ensureFeynmanSettings(settingsPath, bundledSettingsPath, a
                 throw error;
         }
     }
-    const content = JSON.stringify(settings, null, 2) + "\n";
-    if (content === existing?.source)
-        return;
-    mkdirSync(dirname(settingsPath), { recursive: true });
-    writeFileSync(settingsPath, content, "utf8");
+    // Read the file again after model discovery so edits made meanwhile survive;
+    // SettingsManager likewise merges only the keys it changed, under Pi's lock.
+    updateSettingsWithoutPiSetter(settingsPath, appRoot, defaults);
+    await settings.flush();
+    const [writeError] = settings.drainErrors();
+    if (writeError)
+        throw writeError.error;
 }

package/dist/setup/doctor.js

@@ -1,43 +1,26 @@
 import { getUserName as getAlphaUserName, isLoggedIn as isAlphaLoggedIn } from "@companion-ai/alpha-hub/lib";
 import { getValidToken as getValidAlphaToken } from "@companion-ai/alpha-hub/lib/auth";
-import { readFileSync } from "node:fs";
+import { ModelRuntime, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { dirname } from "node:path";
 import { verifyAlphaAuthStatus } from "../alpha-auth-status.js";
 import { formatPiWebAccessDoctorLines, getPiWebAccessStatus } from "../pi/web-access.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";
 import { printInfo, printPanel, printSection } from "../ui/terminal.js";
 import { getCurrentModelSpec } from "../model/commands.js";
 import { buildModelStatusSnapshotFromRecords, getAvailableModelRecords, getSupportedModelRecords } from "../model/catalog.js";
-import { createModelRegistry, getModelsJsonPath } from "../model/registry.js";
+import { createModelRuntime, getModelsJsonPath } from "../model/registry.js";
 import { getConfiguredServiceTier } from "../model/service-tier.js";
-function findProvidersMissingApiKey(modelsJsonPath) {
-    try {
-        const raw = readFileSync(modelsJsonPath, "utf8").trim();
-        if (!raw)
-            return [];
-        const parsed = JSON.parse(raw);
-        const providers = parsed?.providers;
-        if (!providers || typeof providers !== "object")
-            return [];
-        const missing = [];
-        for (const [providerId, config] of Object.entries(providers)) {
-            if (!config || typeof config !== "object")
-                continue;
-            const models = config.models;
-            if (!Array.isArray(models) || models.length === 0)
-                continue;
-            const apiKey = config.apiKey;
-            if (typeof apiKey !== "string" || apiKey.trim().length === 0) {
-                missing.push(providerId);
-            }
-        }
-        return missing;
-    }
-    catch {
-        return [];
-    }
+// Custom providers (in models.json, not Pi's built-in catalog) that list models
+// but have no credential Pi can resolve, so none of their models are available.
+async function findProvidersMissingApiKey(modelRuntime, authPath) {
+    const builtIn = await ModelRuntime.create({ authPath, modelsPath: null, allowModelNetwork: false, refreshOnCreate: false });
+    return modelRuntime
+        .getProviders()
+        .filter((provider) => !builtIn.getProvider(provider.id) && modelRuntime.getModels(provider.id).length > 0)
+        .filter((provider) => !modelRuntime.getProviderAuthStatus(provider.id).configured)
+        .map((provider) => provider.id);
 }
 export async function collectStatusSnapshot(options) {
     const pandocPath = resolveExecutable("pandoc", PANDOC_FALLBACK_PATHS);
@@ -100,8 +83,8 @@ export async function runStatus(options) {
     }
 }
 export async function runDoctor(options) {
-    const settings = readJson(options.settingsPath);
-    const modelRegistry = await createModelRegistry(options.authPath);
+    const settings = SettingsManager.create(options.workingDir, dirname(options.settingsPath), { projectTrusted: false });
+    const modelRuntime = await createModelRuntime(options.authPath);
     const supportedModels = await getSupportedModelRecords(options.authPath);
     const modelStatus = await collectStatusSnapshot(options);
     const pandocPath = resolveExecutable("pandoc", PANDOC_FALLBACK_PATHS);
@@ -135,9 +118,9 @@ export async function runDoctor(options) {
             .join(", ");
         console.log(`  authenticated sample: ${sample}`);
     }
-    console.log(`default model: ${typeof settings.defaultProvider === "string" && typeof settings.defaultModel === "string"
-        ? `${settings.defaultProvider}/${settings.defaultModel}`
-        : "not set"}`);
+    const defaultProvider = settings.getDefaultProvider();
+    const defaultModel = settings.getDefaultModel();
+    console.log(`default model: ${defaultProvider && defaultModel ? `${defaultProvider}/${defaultModel}` : "not set"}`);
     console.log(`default model valid: ${modelStatus.modelValid ? "yes" : "no"}`);
     console.log(`authenticated providers: ${modelStatus.authenticatedProviderCount}`);
     console.log(`authenticated models: ${modelStatus.authenticatedModelCount}`);
@@ -146,7 +129,7 @@ export async function runDoctor(options) {
     if (modelStatus.recommendedModelReason) {
         console.log(`  why: ${modelStatus.recommendedModelReason}`);
     }
-    const modelsError = modelRegistry.getError();
+    const modelsError = modelRuntime.getError();
     if (modelsError) {
         console.log("models.json: error");
         for (const line of modelsError.split("\n")) {
@@ -156,23 +139,24 @@ export async function runDoctor(options) {
     else {
         const modelsJsonPath = getModelsJsonPath(options.authPath);
         console.log(`models.json: ${modelsJsonPath}`);
-        const missingApiKeyProviders = findProvidersMissingApiKey(modelsJsonPath);
+        const missingApiKeyProviders = await findProvidersMissingApiKey(modelRuntime, options.authPath);
         if (missingApiKeyProviders.length > 0) {
             console.log(`  warning: provider(s) missing apiKey: ${missingApiKeyProviders.join(", ")}`);
-            console.log("  note: custom providers with a models[] list need apiKey in models.json to be available.");
+            console.log("  note: custom providers with a models[] list need an apiKey in models.json or a stored key to be available.");
         }
     }
     console.log(`pandoc: ${pandocPath ?? "missing"}`);
     if (process.platform === "win32") {
-        const shellPath = settings.shellPath;
-        console.log(`bash: ${typeof shellPath === "string" ? `${shellPath} (shellPath)` : findWindowsBash()?.path ?? `missing. ${WINDOWS_BASH_MISSING_NOTICE}`}`);
+        const shellPath = settings.getShellPath();
+        console.log(`bash: ${shellPath ? `${shellPath} (shellPath)` : findWindowsBash()?.path ?? `missing. ${WINDOWS_BASH_MISSING_NOTICE}`}`);
     }
     console.log(`browser preview runtime: ${browserPath ?? "missing"}`);
     for (const line of formatPiWebAccessDoctorLines()) {
         console.log(line);
     }
-    console.log(`quiet startup: ${settings.quietStartup === "header" ? "header only" : settings.quietStartup === true ? "enabled" : "disabled"}`);
-    console.log(`theme: ${typeof settings.theme === "string" ? settings.theme : "not set"}`);
+    const quietStartup = settings.getQuietStartup();
+    console.log(`quiet startup: ${quietStartup === "header" ? "header only" : quietStartup === true ? "enabled" : "disabled"}`);
+    console.log(`theme: ${settings.getThemeSetting() ?? "not set"}`);
     if (missingPiBits.length > 0) {
         console.log("pi runtime: missing files");
         for (const entry of missingPiBits) {

package/extensions/research-tools/service-tier.ts

@@ -34,6 +34,7 @@ function normalizeServiceTier(value: string | undefined): FeynmanServiceTier | u
 	return SERVICE_TIER_SET.has(normalized) ? (normalized as FeynmanServiceTier) : undefined;
 }
 
+// serviceTier is Feynman's key; Pi's SettingsManager has no getter or setter for it, so it is read and written directly.
 function getConfiguredServiceTier(settingsPath: string): FeynmanServiceTier | undefined {
 	try {
 		const parsed = JSON.parse(readFileSync(settingsPath, "utf8")) as { serviceTier?: string };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@companion-ai/feynman",
-  "version": "0.5.41",
+  "version": "0.5.43",
   "description": "The open source AI research agent.",
   "license": "MIT",
   "type": "module",
@@ -79,21 +79,20 @@
   "dependencies": {
     "@clack/prompts": "^1.8.1",
     "@companion-ai/alpha-hub": "0.1.7",
-    "@earendil-works/chord": "1.1.0",
-    "@earendil-works/pi-codemode": "1.1.0",
-    "@earendil-works/pi-mcp": "1.1.0",
-    "@earendil-works/pi-telemetry": "1.1.0",
+    "@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-agent-core": "1.1.0",
-    "@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": "*"
   },