@companion-ai/feynman 0.5.16 → 0.5.18

package/.feynman/agents/researcher.md

@@ -31,7 +31,7 @@ You are Feynman's evidence-gathering subagent.
 | Biomedical papers | `source: "pubmed"`, then `source: "europepmc"` for open-access full-text sections | `semanticscholar` for citation counts |
 | Citation graph | `source: "openalex"` with `openalex_citations:` / `openalex_references:` | `semanticscholar` citation counts to spot seminal work |
 | Conceptual or recent work that keyword search misses | `source: "openalex"` with a `semantic:` query prefix | `semanticscholar` with `sort: "relevance"` |
-| Web, docs, repos, grey literature | `web_search` (if the default provider fails or is rate-limited, retry with `provider: "parallel-mcp"`, which needs no key) | `fetch_content` on the best results |
+| Web, docs, repos, grey literature | `web_search` (if the default provider fails or is rate-limited, retry with `provider` set to the plain string `parallel-mcp`, not a JSON-encoded list; it needs no key) | `fetch_content` on the best results |
 | Known paper ID | `source: "arxiv"` for arXiv IDs, `source: "crossref"` for DOIs | `fetch_content` on `arxiv.org/html/<id>` for full text |
 
 Run 2–4 reworded queries for each question (synonyms, the method's name, the problem's name) and merge the results. Do not trust one query's ranking; seminal papers often appear only under one phrasing or one sort order.

package/RELEASES.md

@@ -6,6 +6,20 @@ GitHub release notes are generated from the matching `## vX.Y.Z` section in this
 
 ## Unreleased
 
+## v0.5.18 - 2026-09-30
+
+- **A rate-limited paper index no longer ends a research step.** When Semantic Scholar is rate-limited or down, a search is answered from OpenAlex, and an OpenAlex topic search that hits OpenAlex's anonymous rate limit or an outage is answered from Semantic Scholar. The result says first which index answered and why. Lookups by OpenAlex ID, DOI, author, venue, or citation still report the error, since the other index has no equivalent.
+- **alphaXiv tools answer when alphaXiv cannot.** If your alphaXiv login expired or alphaXiv does not respond, `alpha_search` returns OpenAlex semantic search results and `alpha_get_paper` returns the arXiv metadata and abstract for an arXiv ID, each marked as a fallback. Run `feynman alpha login` to get alphaXiv's reports back.
+- pi-web-access 0.35.0: OpenAI web search works when you signed in with ChatGPT (`feynman model login openai`), and Brave search keeps to its rate limits. The researcher is told to pass a search provider as a plain string, since some models sent `provider: "[\"parallel-mcp\"]"`, which `web_search` rejects; nicobailon/pi-web-access#491 makes `web_search` accept that form too.
+
+## v0.5.17 - 2026-09-30
+
+- **`feynman model login openai` works again.** Since Pi 0.99, Sign in with ChatGPT needs a stable ID for the installation, which Feynman did not pass, so the login failed at once with "requires a device ID (UUID)". Feynman now shares the `deviceId` Pi's own `/login` keeps in `~/.feynman/agent/settings.json`.
+- **Windows finds per-user Git Bash.** Pi looks for Git Bash only under Program Files and on PATH, but a per-user Git for Windows install puts only `Git\cmd` on PATH, so shell commands failed with "No bash shell found" (about one in five Windows installs that run tools). Feynman now finds that Git Bash and gives it to Pi. When there is no Bash at all, Feynman says so before the session starts, and `feynman doctor` reports the `bash` it found.
+- Pressing Enter at the "paste the authorization code / redirect URL" login prompt no longer ends the login with "Missing authorization code"; Feynman asks again, and finishing in the browser still works.
+- API keys are now masked as you paste them during setup, and a key with non-ASCII characters (for example typed with a non-Latin keyboard layout) is rejected with an explanation instead of failing every request with "Cannot convert argument to a ByteString".
+- A rejected `SEMANTIC_SCHOLAR_API_KEY` now says so instead of `request failed: 403 Forbidden`.
+
 ## v0.5.16 - 2026-09-30
 
 - **Subagent research files land in the workspace.** When a workflow gave a subagent a relative output path such as `outputs/.drafts/<slug>-research-web.md`, pi-subagents saved it under `~/.feynman/sessions/subagent-artifacts/outputs/<run>/` instead, so the lead agent could not find the research notes, citations, or verification it asked for (about one in seven installs running research workflows hit this in the last week). Relative subagent outputs now resolve against the workspace, the researcher, reviewer, verifier, and writer no longer default to generic file names such as `research.md`, and `/deepresearch` and `/lit` name every subagent file under `outputs/.drafts/`. If you set `singleRunOutputBaseDir` in `~/.feynman/agent/extensions/subagent/config.json`, Feynman keeps your value.

package/dist/cli.js

@@ -20,7 +20,7 @@ import { ensureFeynmanHome, getDefaultSessionDir, getFeynmanAgentDir, getFeynman
 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 { BUNDLED_PI_PACKAGES, buildPiEnv } from "./pi/runtime.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";
 import { buildModelStatusSnapshotFromRecords, getAuthenticatedModelRecords, isProClassModelSpec, getSupportedModelRecords, } from "./model/catalog.js";
@@ -681,6 +681,12 @@ async function runMain(input) {
             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()) {
+            preLaunchNotice = [preLaunchNotice, WINDOWS_BASH_MISSING_NOTICE].filter(Boolean).join("\n");
+        }
+    }
     await launchPiChat({
         ...piOptions,
         mode,

package/dist/model/commands.js

@@ -1,8 +1,10 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import { exec as execCallback } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { dirname, resolve } from "node:path";
 import { promisify } from "node:util";
 import { readJson } from "../pi/settings.js";
-import { promptChoice, promptSelect, promptText } from "../setup/prompts.js";
+import { promptChoice, promptSecret, promptSelect, promptText, 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";
@@ -624,7 +626,7 @@ 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 promptText("Paste API key (leave empty to use env var instead)", "");
+    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\`).`);
@@ -729,6 +731,17 @@ export async function authenticateModelProvider(authPath, settingsPath) {
     printInfo("Authentication cancelled.");
     return false;
 }
+// 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");
+    return deviceId;
+}
 export async function loginModelProvider(authPath, providerId, settingsPath) {
     if (providerId) {
         const resolvedProvider = await resolveModelProviderForCommand(authPath, providerId);
@@ -762,7 +775,13 @@ export async function loginModelProvider(authPath, providerId, settingsPath) {
                     hint: option.description,
                 })), undefined, prompt.signal);
             }
-            return promptText(prompt.message, "", prompt.placeholder, prompt.signal);
+            if (prompt.type === "secret") {
+                return promptSecret(prompt.message, prompt.signal);
+            }
+            // An empty answer here fails the login with "Missing authorization code";
+            // keep asking, since the browser callback can still finish meanwhile.
+            const required = prompt.type === "manual_code" ? "Paste the redirect URL or code, or finish signing in in the browser." : undefined;
+            return promptText(prompt.message, "", prompt.placeholder, prompt.signal, required);
         },
         notify: (event) => {
             if (event.type === "auth_url") {
@@ -790,7 +809,7 @@ export async function loginModelProvider(authPath, providerId, settingsPath) {
             }
         },
         signal: abortController.signal,
-    });
+    }, { getDeviceId: () => getOrCreateDeviceId(authPath) });
     printSuccess(`Model provider login complete: ${provider.id}`);
     await maybeSetRecommendedDefaultModel(settingsPath, authPath);
     return true;

package/dist/pi/runtime.js

@@ -1,6 +1,6 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { delimiter, dirname, resolve } from "node:path";
+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";
 // Pi packages shipped as Feynman dependencies and loaded from their install
@@ -116,6 +116,31 @@ export function buildPiArgs(options) {
     }
     return args;
 }
+// Pi looks for Git Bash only under Program Files and for bash.exe on PATH. A
+// per-user Git for Windows install (%LOCALAPPDATA%\Programs\Git) puts only
+// Git\cmd on PATH, so Pi reports "No bash shell found" although Git Bash is
+// installed. `addDir` is the Git\bin directory to add to Pi's PATH in that case.
+export function findWindowsBash(env = process.env, exists = existsSync) {
+    const pathDirs = (env.PATH ?? env.Path ?? "").split(";").filter(Boolean);
+    const known = [env.ProgramFiles, env["ProgramFiles(x86)"]]
+        .filter((dir) => Boolean(dir))
+        .map((dir) => win32.join(dir, "Git", "bin", "bash.exe"));
+    const found = [...known, ...pathDirs.map((dir) => win32.join(dir, "bash.exe"))].find(exists);
+    if (found)
+        return { path: found };
+    const gitRoots = [
+        // git.exe lives in Git\cmd or Git\mingw64\bin.
+        ...pathDirs.filter((dir) => exists(win32.join(dir, "git.exe"))).flatMap((dir) => [win32.dirname(dir), win32.dirname(win32.dirname(dir))]),
+        ...(env.LOCALAPPDATA ? [win32.join(env.LOCALAPPDATA, "Programs", "Git")] : []),
+    ];
+    for (const root of gitRoots) {
+        const bash = win32.join(root, "bin", "bash.exe");
+        if (exists(bash))
+            return { path: bash, addDir: win32.join(root, "bin") };
+    }
+    return undefined;
+}
+export const WINDOWS_BASH_MISSING_NOTICE = "No Bash found: Feynman runs shell commands with Bash, so they will fail. Install Git for Windows (https://git-scm.com/download/win), or set shellPath in ~/.feynman/agent/settings.json to another bash.exe.";
 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);
@@ -123,7 +148,9 @@ export function buildPiEnv(options, executables) {
     const browserPath = process.env.PUPPETEER_EXECUTABLE_PATH ?? executables?.browser ?? resolveExecutable("google-chrome", BROWSER_FALLBACK_PATHS);
     return {
         ...process.env,
-        PATH: `${binPath}${delimiter}${process.env.PATH ?? ""}`,
+        PATH: [binPath, process.env.PATH ?? "", process.platform === "win32" ? findWindowsBash()?.addDir : undefined]
+            .filter(Boolean)
+            .join(delimiter),
         FEYNMAN_VERSION: options.feynmanVersion,
         FEYNMAN_NODE_EXECUTABLE: process.execPath,
         FEYNMAN_BIN_PATH: getFeynmanCliBinPath(options.appRoot),

package/dist/setup/doctor.js

@@ -5,7 +5,7 @@ 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 { readJson } from "../pi/settings.js";
-import { validatePiInstallation } from "../pi/runtime.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";
@@ -163,6 +163,10 @@ export async function runDoctor(options) {
         }
     }
     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}`}`);
+    }
     console.log(`browser preview runtime: ${browserPath ?? "missing"}`);
     for (const line of formatPiWebAccessDoctorLines()) {
         console.log(line);

package/dist/setup/prompts.js

@@ -1,4 +1,4 @@
-import { confirm as clackConfirm, intro as clackIntro, isCancel, multiselect as clackMultiselect, outro as clackOutro, select as clackSelect, text as clackText, } from "@clack/prompts";
+import { confirm as clackConfirm, intro as clackIntro, isCancel, multiselect as clackMultiselect, outro as clackOutro, password as clackPassword, select as clackSelect, text as clackText, } from "@clack/prompts";
 export class SetupCancelledError extends Error {
     constructor(message = "setup cancelled") {
         super(message);
@@ -36,17 +36,30 @@ export async function promptOutro(message) {
     ensureInteractiveTerminal();
     clackOutro(message);
 }
-export async function promptText(question, defaultValue = "", placeholder, signal) {
+export async function promptText(question, defaultValue = "", placeholder, signal, requiredMessage) {
     ensureInteractiveTerminal();
     const value = guardCancelled(await clackText({
         message: question,
         initialValue: defaultValue || undefined,
         placeholder: placeholder ?? (defaultValue || undefined),
         signal,
+        validate: requiredMessage ? (input) => (input?.trim() ? undefined : requiredMessage) : undefined,
     }));
     const normalized = String(value ?? "").trim();
     return normalized || defaultValue;
 }
+export async function promptSecret(question, signal, validate) {
+    ensureInteractiveTerminal();
+    const value = guardCancelled(await clackPassword({ message: question, signal, validate: validate ? (input) => validate((input ?? "").trim()) : undefined }));
+    return String(value ?? "").trim();
+}
+// API keys are printable ASCII. A key typed with a non-Latin keyboard layout
+// fails every request with "Cannot convert argument to a ByteString".
+export function validateApiKeyInput(value) {
+    return /^[\x21-\x7e]*$/.test(value)
+        ? undefined
+        : "API keys contain only ASCII letters, digits, and symbols. Check your keyboard input language and paste the key again.";
+}
 export async function promptSelect(question, options, initialValue, signal) {
     ensureInteractiveTerminal();
     const selection = guardCancelled(await clackSelect({

package/extensions/research-tools/alpha.ts

@@ -13,6 +13,8 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
 import { extractPaperSections } from "./alpha-sections.js";
+import { searchArxiv } from "./science-database-arxiv.js";
+import { searchOpenAlex } from "./science-database-openalex.js";
 
 function formatText(value: unknown): string {
 	if (typeof value === "string") return value;
@@ -21,11 +23,23 @@ function formatText(value: unknown): string {
 
 // alphaXiv's API has changed without notice before; when a call fails, point
 // the model at the other paper sources instead of leaving it on a broken tool.
-async function withPaperFallback<T>(run: () => Promise<T>): Promise<T> {
+const ARXIV_ID = /(?:^|arxiv\.org\/(?:abs|pdf)\/|alphaxiv\.org\/(?:abs|overview)\/)(\d{4}\.\d{4,5}(?:v\d+)?|[a-z-]+(?:\.[A-Z]{2})?\/\d{7}(?:v\d+)?)/i;
+
+// When alphaXiv does not answer (expired login, outage), answer from another
+// paper source and say so first, instead of failing the research step.
+async function withPaperFallback<T>(
+	run: () => Promise<T>,
+	fallback?: { source: string; run: () => Promise<Record<string, unknown>> },
+): Promise<T | Record<string, unknown>> {
 	try {
 		return await run();
 	} catch (error) {
 		const message = (error instanceof Error ? error.message : String(error)).replace("`alpha login`", "`feynman alpha login`");
+		if (fallback) {
+			try {
+				return { fallbackNote: `alphaXiv did not answer (${message}); these results are from ${fallback.source}.`, ...(await fallback.run()) };
+			} catch {}
+		}
 		throw new Error(
 			`${message}\nalphaXiv did not answer this call. Use feynman_science_database_search (source "arxiv" or "semanticscholar") or fetch_content on https://arxiv.org/abs/<id> instead.`,
 		);
@@ -65,7 +79,10 @@ export function registerAlphaTools(pi: ExtensionAPI, signedIn = isLoggedIn()): v
 			),
 		}),
 		async execute(_toolCallId, params) {
-			const result = await withPaperFallback(() => searchPapers(params.query, params.mode?.trim() || "semantic"));
+			const result = await withPaperFallback(() => searchPapers(params.query, params.mode?.trim() || "semantic"), {
+				source: "OpenAlex semantic search",
+				run: () => searchOpenAlex({ source: "openalex", query: `semantic: ${params.query}`, limit: 10 }),
+			});
 			return { content: [{ type: "text", text: formatText(result) }], details: result };
 		},
 	});
@@ -87,7 +104,14 @@ export function registerAlphaTools(pi: ExtensionAPI, signedIn = isLoggedIn()): v
 			sections: Type.Optional(paperSectionsSchema),
 		}),
 		async execute(_toolCallId, params) {
-			const result = await withPaperFallback(() => getPaper(params.paper, { fullText: params.fullText }));
+			const arxivId = ARXIV_ID.exec(params.paper.trim())?.[1];
+			const result = await withPaperFallback(() => getPaper(params.paper, { fullText: params.fullText }), arxivId ? {
+				source: "arXiv metadata and abstract (no full text or sections)",
+				run: () => searchArxiv({ query: arxivId }),
+			} : undefined);
+			if ("fallbackNote" in result) {
+				return { content: [{ type: "text", text: formatText(result) }], details: result };
+			}
 			const extracted = extractPaperSections(result.content, params.section, params.sections);
 			const filteredResult = extracted.requested.length
 				? {

package/extensions/research-tools/science-databases.ts

@@ -270,6 +270,9 @@ async function fetchSemanticScholar(url: URL): Promise<unknown> {
 		try {
 			return await fetchJson(url, headers);
 		} catch (error) {
+			if (apiKey && error instanceof ScienceDatabaseRequestError && error.status === 403) {
+				throw new ScienceDatabaseRequestError("Semantic Scholar rejected SEMANTIC_SCHOLAR_API_KEY (HTTP 403). Check the key, or unset it to use the shared pool; search with source openalex meanwhile.", 403);
+			}
 			if (!(error instanceof ScienceDatabaseRequestError) || error.status !== 429) throw error;
 			if (attempt >= 1) {
 				throw new ScienceDatabaseRequestError(apiKey
@@ -377,19 +380,54 @@ async function searchSemanticScholar(params: ScienceDatabaseSearchParams): Promi
 	};
 }
 
+// OpenAlex lookups by ID, DOI, author, venue, or citation have no Semantic
+// Scholar equivalent; only plain topic searches fall back.
+const OPENALEX_LOOKUP_QUERY =
+	/^(?:openalex_\w+|rate-limit|authors?|author-search|sources?|venues?|citations?|references?|work|detail)(?::|\s|$)|^(?:W\d+|doi:\s*10\.|10\.\S+\/)/i;
+
+function isIndexUnavailable(error: unknown): boolean {
+	if (error instanceof ScienceDatabaseRequestError) return error.status === 429 || error.status >= 500;
+	return error instanceof Error && /^OpenAlex request failed: (?:429|5\d\d)\b/.test(error.message);
+}
+
+// A rate-limited or overloaded index should not end a research step: answer a
+// topic search from the other general index, and say so first in the result.
+async function withIndexFallback(
+	run: () => Promise<Record<string, unknown>>,
+	fallback: (() => Promise<Record<string, unknown>>) | undefined,
+	describe: (reason: string) => string,
+): Promise<Record<string, unknown>> {
+	try {
+		return await run();
+	} catch (error) {
+		if (!fallback || !isIndexUnavailable(error)) throw error;
+		let result: Record<string, unknown>;
+		try {
+			result = await fallback();
+		} catch {
+			throw error;
+		}
+		return { fallbackNote: describe(error instanceof Error ? error.message : String(error)), ...result };
+	}
+}
+
 async function scienceDatabaseSearch(params: ScienceDatabaseSearchParams): Promise<Record<string, unknown>> {
 	if (params.source === "arxiv") return searchArxiv(params);
 	if (params.source === "biorxiv") return searchPreprints(params, "biorxiv");
 	if (params.source === "medrxiv") return searchPreprints(params, "medrxiv");
 	if (params.source === "pubmed") return searchPubMed(params);
 	if (params.source === "crossref") return searchCrossref(params);
-	if (params.source === "semanticscholar") return searchSemanticScholar(params);
+	const openAlex = () => searchOpenAlex({ limit: params.limit, query: params.query, source: "openalex" });
+	const semanticScholar = () => searchSemanticScholar({ ...params, source: "semanticscholar" });
+	if (params.source === "semanticscholar") {
+		return withIndexFallback(semanticScholar, openAlex, (reason) => `Semantic Scholar was unavailable (${reason}); these results are from OpenAlex.`);
+	}
 	if (params.source === "openalex") {
-		return searchOpenAlex({
-			limit: params.limit,
-			query: params.query,
-			source: params.source,
-		});
+		return withIndexFallback(
+			openAlex,
+			OPENALEX_LOOKUP_QUERY.test(params.query.trim()) ? undefined : semanticScholar,
+			(reason) => `OpenAlex was unavailable (${reason}); these results are from Semantic Scholar.`,
+		);
 	}
 	return searchEuropePmc(params);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@companion-ai/feynman",
-  "version": "0.5.16",
+  "version": "0.5.18",
   "description": "Research-first CLI agent built on Pi and alphaXiv",
   "license": "MIT",
   "type": "module",
@@ -83,7 +83,7 @@
     "pi-btw": "0.6.1",
     "pi-docparser": "4.0.0",
     "pi-subagents": "0.73.1",
-    "pi-web-access": "0.34.0",
+    "pi-web-access": "0.35.0",
     "posthog-node": "^5.53.0",
     "undici": "^8.11.2"
   },