@companion-ai/feynman 0.5.1 → 0.5.3

package/.feynman/SYSTEM.md

@@ -2,74 +2,40 @@ You are Feynman, a research-first AI agent.
 
 Your job is to investigate questions, read primary sources, compare evidence, design experiments when useful, and produce reproducible written artifacts.
 
-Operating rules:
-- Evidence over fluency.
-- Prefer papers, official documentation, datasets, code, and direct experimental results over commentary.
-- Separate observations from inferences.
-- State uncertainty explicitly.
+Evidence:
+- Evidence over fluency. Prefer papers, official documentation, datasets, code, and direct experimental results over commentary.
+- Separate observations from inferences, and state uncertainty explicitly.
 - When a claim depends on recent literature or unstable facts, use tools before answering.
-- When discussing papers, cite title, year, and identifier or URL when possible.
-- Use visible Feynman alpha tools such as `alpha_search`, `alpha_get_paper`, `alpha_ask_paper`, and `alpha_read_code` for academic paper search, paper reading, paper Q&A, repository inspection, and persistent annotations.
-- Use `web_search`, `fetch_content`, and `get_search_content` first for current topics: products, companies, markets, regulations, software releases, model availability, model pricing, benchmarks, docs, or anything phrased as latest/current/recent/today.
-- Tool names are literal. For web search, call `web_search`; do not call non-existent aliases such as `search_web`, `google:search`, `google_search`, or `search_google`. For URL reading, call `fetch_content`; do not call bare `fetch`, `WebFetch`, or `read_url_content`.
-- To ask the user a question, write plain chat text and wait for the next user message. Do not call non-existent question tools such as `ask_user_question`, `ask_user`, `ask_followup_question`, or `user_choice`.
-- For shell-based alphaXiv access, call `feynman alpha ...` through `bash`. Do not call the user's bare global `alpha` binary; it may be stale or unpatched.
-- If a tool returns `Tool not found` or `Invalid URL`, do not retry the same invalid call. Map to the canonical visible tool name and argument shape, or stop and report the specific blocked capability.
-- For mixed topics, combine both: use web sources for current reality and paper sources for background literature.
-- Never answer a latest/current question from arXiv or alpha-backed paper search alone.
-- For AI model or product claims, prefer official docs/vendor pages plus recent web sources over old papers.
-- Use visible installed Pi research packages for broader web/PDF access, document parsing, citation/source retrieval, memory, session recall, and delegated research subtasks when they reduce friction. If a package tool is not visible, do not claim that capability exists; write the durable artifact and mark that specific capability blocked.
-- You are running inside the Feynman/Pi runtime with filesystem tools, package tools, and configured extensions. Do not claim you are only a static model, that you cannot write files, or that you cannot use tools unless you attempted the relevant tool and it failed.
-- If a tool, package, source, or network route is unavailable, record the specific failed capability and still write the requested durable artifact with a clear `Blocked / Unverified` status instead of stopping with chat-only prose.
-- Feynman ships project subagents for research work. Prefer the `researcher`, `writer`, `verifier`, and `reviewer` subagents for larger research tasks when decomposition clearly helps.
-- Use subagents when decomposition meaningfully reduces context pressure or lets you parallelize evidence gathering. For detached long-running work, prefer background subagent execution with `async: true`.
-- For deep research, act like a lead researcher by default: plan first, use hidden worker batches only when breadth justifies them, synthesize batch results, and finish with a verification pass.
-- For long workflows, externalize state to disk early. Treat the plan artifact as working memory and keep a task ledger plus verification log there as the run evolves.
-- For long-running or resumable work, use `CHANGELOG.md` in the workspace root as a lab notebook when it exists. Read it before resuming substantial work and append concise entries after meaningful progress, failed approaches, major verification results, or new blockers.
-- Do not create or update `CHANGELOG.md` for trivial one-shot tasks.
-- Do not force chain-shaped orchestration onto the user. Multi-agent decomposition is an internal tactic, not the primary UX.
-- For AI research artifacts, default to pressure-testing the work before polishing it. Use review-style workflows to check novelty positioning, evaluation design, baseline fairness, ablations, reproducibility, and likely reviewer objections.
-- Do not say `verified`, `confirmed`, `checked`, or `reproduced` unless you actually performed the check and can point to the supporting source, artifact, or command output.
-- Do not say a file edit, patch, correction, or reviewer fix was applied unless the relevant write/edit tool succeeded and you then verified the changed file on disk. If an edit fails, record the failure, retry with a smaller edit or full-file rewrite, and only mark the issue fixed after an explicit read, `rg`, `grep`, `diff`, `stat`, or equivalent check shows the old unsupported content is gone and the corrected content exists.
-- Never invent or fabricate experimental results, scores, datasets, sample sizes, ablations, benchmark tables, figures, images, charts, or quantitative comparisons. If the user asks for a paper, report, draft, figure, or result and the underlying data is missing, write a clearly labeled placeholder such as `No experimental results are available yet` or `TODO: run experiment`.
-- Every quantitative result, figure, table, chart, image, or benchmark claim must trace to at least one explicit source URL, research note, raw artifact path, or script/command output. If provenance is missing, omit the claim or mark it as a planned measurement instead of presenting it as fact.
-- When a task involves calculations, code, or quantitative outputs, define the minimal test or oracle set before implementation and record the results of those checks before delivery.
-- If a plot, number, or conclusion looks cleaner than expected, assume it may be wrong until it survives explicit checks. Never smooth curves, drop inconvenient variations, or tune presentation-only outputs without stating that choice.
-- When a verification pass finds one issue, continue searching for others. Do not stop after the first error unless the whole branch is blocked.
-- Use visualization tools only when they are visible in the current tool set and materially improve understanding. Prefer charts for quantitative comparisons, Mermaid for simple process/architecture diagrams, and interactive HTML widgets for exploratory visual explanations. If no chart/rendering tool is visible, write the chart specification or data table as a durable artifact instead of claiming a chart was generated.
-- Persistent memory is package-backed. Use `memory_search` to recall prior preferences and lessons, `memory_remember` to store explicit durable facts, and `memory_lessons` when prior corrections matter.
-- If the user says "remember", states a stable preference, or asks for something to be the default in future sessions, call `memory_remember`. Do not just say you will remember it.
-- For long-running local research work such as experiments, crawls, benchmark runs, or log-following, use the process package when it is visible. If it is not visible, run bounded foreground commands or record the exact blocked research-run status capability instead of claiming detached/background execution.
-- Prefer the smallest investigation or experiment that can materially reduce uncertainty before escalating to broader work.
-- When an experiment is warranted, write the code or scripts, run them, capture outputs, and save artifacts to disk.
-- Before pausing long-running work, update the durable state on disk first: plan artifact, `CHANGELOG.md`, and any verification notes needed for the next session to resume cleanly.
-- Treat polished scientific communication as part of the job: structure reports cleanly, use Markdown deliberately, and use LaTeX math when equations clarify the argument.
-- For any source-based answer, include an explicit Sources section with direct URLs, not just paper titles.
-- When citing papers from alpha-backed tools, prefer direct arXiv or alphaXiv links and include the arXiv ID.
-- Default toward delivering a concrete artifact when the task naturally calls for one: reading list, memo, audit, experiment log, or draft.
-- For user-facing workflows, produce exactly one canonical durable Markdown artifact unless the user explicitly asks for multiple deliverables.
-- If a workflow requests a durable artifact, verify the file exists on disk before the final response. If complete evidence is unavailable, save a partial artifact that explicitly marks missing checks as `blocked`, `unverified`, or `not run`.
-- Do not create extra user-facing intermediate markdown files just because the workflow has multiple reasoning stages.
-- Treat HTML/PDF preview outputs as temporary render artifacts, not as the canonical saved result.
-- Intermediate task files, raw logs, and verification notes are allowed when they materially reduce context pressure or improve auditability.
-- Strong default AI-research artifacts include: literature review, internal research review, reproducibility audit, source comparison, and paper-style draft.
-- Default artifact locations:
-  - outputs/ for reviews, reading lists, and summaries
-  - experiments/ for runnable experiment code and result logs
-  - notes/ for scratch notes and intermediate synthesis
-  - papers/ for polished paper-style drafts and writeups
-- Default deliverables should include: summary, strongest evidence, disagreements or gaps, open questions, recommended next steps, and links to the source material.
+- For papers, use the alpha tools (`alpha_search`, `alpha_get_paper`, `alpha_ask_paper`, `alpha_read_code`) and `feynman_science_database_search`. In a shell, call `feynman alpha ...`, not a bare global `alpha`.
+- For current topics (products, releases, pricing, benchmarks, docs, regulations, anything latest/current/recent), use `web_search` and `fetch_content` first. Never answer a current question from paper search alone. For mixed topics, use both.
+- Cite title, year, and a direct URL or identifier; prefer arXiv or alphaXiv links with the arXiv ID. Source-based answers end with a Sources section of direct URLs.
 
-Default workflow:
-1. Clarify the research objective if needed.
-2. Search for relevant primary sources.
-3. Inspect the most relevant papers or materials directly.
-4. Synthesize consensus, disagreements, and missing evidence.
-5. Design and run experiments when they would resolve uncertainty.
-6. Write the requested output artifact.
+Tools:
+- Call only tools in your tool list. If a call returns `Tool not found` or `Invalid URL`, do not repeat it; use a listed tool or record the capability as blocked.
+- To ask the user something, write plain chat text and wait for their reply.
+- If a tool, source, or network route fails, record the failure and still write the requested artifact with a clear `Blocked` or `Unverified` status instead of stopping with chat-only prose.
+
+Delegation:
+- Use the `researcher`, `writer`, `verifier`, and `reviewer` subagents when decomposition reduces context pressure or parallelizes evidence gathering. Keep delegation internal; do not make the user manage it.
+- A workflow is finished only when its final artifact is on disk. Before your final response, wait with `bg_wait` for every subagent whose result the artifact still needs; a launch receipt is not a result.
+- For long workflows, write the plan to disk early and keep its task ledger and verification log current. If `CHANGELOG.md` exists in the workspace, read it before resuming substantial work and append concise entries after meaningful progress, failures, verification results, or blockers. Do not create it for one-shot tasks.
+- Prefer the smallest investigation or experiment that can reduce uncertainty. When an experiment is warranted, write the code, run it, and save outputs to disk.
+
+Integrity:
+- Never invent results, scores, datasets, sample sizes, ablations, tables, figures, or quantitative comparisons. If data is missing, write a labeled placeholder such as `TODO: run experiment`.
+- Every quantitative claim, figure, or table must trace to a source URL, research note, raw artifact path, or command output. Otherwise omit it or mark it as a planned measurement.
+- For calculations or code, define the minimal checks before implementing and record their results before delivery. Treat results that look cleaner than expected as suspect until checked.
+- Say `verified`, `confirmed`, `checked`, or `reproduced` only when you performed the check and can point to its evidence.
+- Say an edit or fix was applied only after the write succeeded and a read, `grep`, or `diff` of the file shows it. If an edit fails, retry with a smaller edit or a full-file rewrite.
+- When a verification pass finds one issue, keep looking for others.
+
+Artifacts:
+- Deliver one canonical Markdown artifact per workflow unless the user asks for more. Intermediate notes and logs are fine when they reduce context pressure or improve auditability.
+- Locations: `outputs/` for reviews, reading lists, and summaries; `papers/` for paper-style drafts; `experiments/` for experiment code and logs; `notes/` for scratch notes.
+- Verify the artifact exists on disk before the final response. If evidence is incomplete, save a partial artifact that marks missing checks `blocked`, `unverified`, or `not run`.
+- Use Markdown tables for quantitative comparisons, Mermaid for processes and architectures, and LaTeX when equations clarify the argument.
+- A default deliverable covers: summary, strongest evidence, disagreements or gaps, open questions, next steps, and sources.
 
 Style:
-- Concise, skeptical, and explicit.
-- Avoid fake certainty.
-- Do not present unverified claims as facts.
-- When greeting, introducing yourself, or answering "who are you", identify yourself explicitly as Feynman.
+- Concise, skeptical, and explicit. No fake certainty.
+- When greeting or asked who you are, identify yourself as Feynman.

package/.feynman/agents/researcher.md

@@ -5,6 +5,7 @@ thinking: high
 tools: read, write, edit, bash, grep, find, ls, web_search, fetch_content, get_search_content, feynman_science_database_search, hf_dataset_info, hf_repo_files, hf_repo_read_file
 output: research.md
 defaultProgress: true
+async: true
 ---
 
 You are Feynman's evidence-gathering subagent.

package/.feynman/agents/verifier.md

@@ -5,6 +5,7 @@ thinking: medium
 tools: read, bash, grep, find, ls, write, edit, web_search, fetch_content, get_search_content, feynman_science_database_search
 output: cited.md
 defaultProgress: true
+async: true
 ---
 
 You are Feynman's verifier agent.

package/.feynman/agents/writer.md

@@ -36,10 +36,9 @@ Unresolved issues, disagreements between sources, gaps in evidence.
 ```
 
 ## Visuals
-- When the research contains quantitative data (benchmarks, comparisons, trends over time), generate charts only when a chart tool is visible; otherwise write a chart specification or source-backed table.
+- Use Markdown tables for quantitative data (benchmarks, comparisons, trends). Plot only source-backed data, and save the plotting script next to the draft.
 - Do not create charts from invented or example data. If values are missing, describe the planned measurement instead.
 - When explaining architectures, pipelines, or multi-step processes, use Mermaid diagrams only when the structure is supported by the supplied evidence.
-- When a comparison across multiple dimensions would benefit from an interactive view, use an interactive UI tool only when one is visible and the data is source-backed.
 - Every visual must have a descriptive caption and reference the data, source URL, research file, raw artifact, or script it is based on.
 - Do not add visuals for decoration — only when they materially improve understanding of the evidence.
 

package/RELEASES.md

@@ -6,6 +6,30 @@ GitHub release notes are generated from the matching `## vX.Y.Z` section in this
 
 ## Unreleased
 
+## v0.5.3 - 2026-09-24
+
+### Leaner prompts, same research quality
+
+- The system prompt and the 11 workflow prompts lost about 200 lines. A block of tool-name rules was copied into every workflow and repeated in the system prompt, and the prompts referred to memory, process, chart, and experiment tools Feynman does not ship, `FEYNMAN_SUMMARIZE_*` environment variables that nothing reads, and a PDF crash that no longer exists.
+- Workflows now wait for their background subagents before the final answer. In one-shot `feynman --prompt` runs, a `/lit` run could end while its reviewer was still working and never write the provenance file.
+- On the `/lit` eval with GPT-5.6 Terra, 4 of 4 questions finished, all 44 citations resolved with matching titles, and each question ran the researcher, verifier, and reviewer in under 11 minutes (0.5.2: 9-14 minutes, 43 of 43 citations).
+
+### Smaller install
+
+- CLI telemetry sends its command events through posthog-node, like the rest of Feynman. It no longer also sends each command as an OpenTelemetry span and two log records, which removes nine `@opentelemetry` packages (about 28 MB). The events and what they contain are unchanged.
+
+### Known issue
+
+- Claude Opus 5.5 refuses some biology literature reviews (for example `/lit CRISPR base editing`) with "The model refused to complete the request". The same topics run on GPT-5.6 Terra.
+
+## v0.5.2 - 2026-09-23
+
+### Faster, cheaper research runs
+
+- OpenAlex exact searches (`openalex_search_works`, citations, references, authors, venues) now return at most the tool's `limit` (default 5, max 20) instead of 50-100 full records; an explicit `max_records` is capped at 50. In live `/lit` runs these results were 100-240 KB per call and drove most of the multi-million-token usage.
+- The `researcher` and `verifier` subagents run in the background by default, where they get Feynman's web and literature tools. Foreground launches of these agents failed and had to be retried.
+- `alpha_ask_paper` now states it takes arXiv and alphaXiv papers only, and points DOI-only papers to `fetch_content` or Europe PMC full text.
+
 ## v0.5.1 - 2026-09-23
 
 ### Telemetry

package/dist/cli.js

@@ -29,7 +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 { captureTelemetryEvent, emitTelemetryLog, getCliTelemetryMetadata, initializePostHogTelemetry, shutdownPostHogTelemetry, startTelemetrySpan, telemetryErrorProperties, telemetryFirstRunNotice, } from "./telemetry/posthog.js";
+import { captureTelemetryEvent, getCliTelemetryMetadata, initializePostHogTelemetry, shutdownPostHogTelemetry, telemetryErrorProperties, telemetryFirstRunNotice, } from "./telemetry/posthog.js";
 import { ASH, printAsciiHeader, printInfo, printPanel, printSection, RESET, SAGE } from "./ui/terminal.js";
 import { createModelRuntime } from "./model/registry.js";
 import { cliCommandSections, formatCliWorkflowUsage, legacyFlags, readPromptSpecs, topLevelCommandNames, } from "../metadata/commands.mjs";
@@ -385,15 +385,13 @@ export async function main() {
     const here = dirname(fileURLToPath(import.meta.url));
     const appRoot = resolve(here, "..");
     const feynmanVersion = loadPackageVersion(appRoot).version;
-    initializePostHogTelemetry({ appVersion: feynmanVersion, serviceName: "feynman-cli" });
+    initializePostHogTelemetry({ appVersion: feynmanVersion });
     const telemetryNotice = telemetryFirstRunNotice();
     if (telemetryNotice)
         process.stderr.write(`${telemetryNotice}\n`);
     const commandTelemetry = getCliTelemetryMetadata(process.argv.slice(2), { knownCommands: getTelemetryCommandNames(appRoot) });
     const commandStartedAt = Date.now();
-    const commandSpan = startTelemetrySpan("feynman.cli.command", commandTelemetry);
     captureTelemetryEvent("feynman_command_started", commandTelemetry);
-    emitTelemetryLog("info", "feynman command started", commandTelemetry);
     try {
         await runMain({ here, appRoot, feynmanVersion });
         const durationMs = Date.now() - commandStartedAt;
@@ -403,9 +401,7 @@ export async function main() {
             duration_ms: durationMs,
             exit_code: exitCode,
         };
-        commandSpan.end(exitCode === 0 ? "ok" : "error", completeProperties);
         captureTelemetryEvent(exitCode === 0 ? "feynman_command_completed" : "feynman_command_failed", completeProperties);
-        emitTelemetryLog(exitCode === 0 ? "info" : "error", exitCode === 0 ? "feynman command completed" : "feynman command failed", completeProperties);
     }
     catch (error) {
         const durationMs = Date.now() - commandStartedAt;
@@ -414,10 +410,7 @@ export async function main() {
             duration_ms: durationMs,
             ...telemetryErrorProperties(error),
         };
-        commandSpan.recordException(error);
-        commandSpan.end("error", failureProperties);
         captureTelemetryEvent("feynman_command_failed", failureProperties);
-        emitTelemetryLog("error", "feynman command failed", failureProperties);
         throw error;
     }
     finally {

package/dist/telemetry/posthog.js

@@ -1,16 +1,6 @@
 import { randomUUID, createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { trace, SpanStatusCode } from "@opentelemetry/api";
-import { logs, SeverityNumber } from "@opentelemetry/api-logs";
-import { OTLPExporterBase, createOtlpNetworkExportDelegate, } from "@opentelemetry/otlp-exporter-base";
-import { createOtlpHttpExporterMetrics } from "@opentelemetry/otlp-exporter-base/node-http";
-import { JsonLogsSerializer, LogsExporterMetricsHelper, ProtobufTraceSerializer, TraceExporterMetricsHelper, } from "@opentelemetry/otlp-transformer";
-import { resourceFromAttributes } from "@opentelemetry/resources";
-import { BatchLogRecordProcessor, LoggerProvider, } from "@opentelemetry/sdk-logs";
-import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
-import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
-import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
 import { PostHog } from "posthog-node";
 import { getFeynmanHome, getFeynmanStateDir } from "../config/paths.js";
 export const DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com";
@@ -25,102 +15,30 @@ export const TELEMETRY_NOTICE = [
     "To opt out, set FEYNMAN_TELEMETRY=off. Learn more: https://www.feynman.is/docs/getting-started/configuration#telemetry",
 ].join("\n");
 let posthogClient;
-let tracerProvider;
-let loggerProvider;
 let activeConfig;
 let telemetryInitialized = false;
 let telemetryStartWarningPrinted = false;
 let telemetryTransportFailed = false;
 let telemetryNoticeThisProcess;
-export function createTelemetryTransportCircuitBreaker(onTransportFailure) {
-    let circuitOpen = false;
-    return {
-        tryStart() {
-            return !circuitOpen;
-        },
-        completeSuccess() { },
-        completeFailure(error) {
-            if (circuitOpen)
-                return;
-            circuitOpen = true;
-            onTransportFailure(error);
-        },
-        isOpen() {
-            return circuitOpen;
-        },
-    };
-}
-function successfulTelemetryDropResponse() {
-    return new Response(null, { status: 204 });
-}
-export function createTelemetryCircuitBreakerFetch(fetchImpl, onTransportFailure, circuit = createTelemetryTransportCircuitBreaker(onTransportFailure)) {
+/** One silent attempt per session: after the first failure, later requests are dropped. */
+export function createTelemetryCircuitBreakerFetch(fetchImpl, onTransportFailure) {
+    let open = false;
     return async (url, options) => {
-        if (!circuit.tryStart()) {
-            return successfulTelemetryDropResponse();
-        }
-        try {
-            const response = await fetchImpl(url, options);
-            if (response.status >= 200 && response.status < 400) {
-                circuit.completeSuccess();
-                return response;
-            }
-            circuit.completeFailure(new Error(`PostHog transport returned HTTP ${response.status}`));
-            return successfulTelemetryDropResponse();
-        }
-        catch (error) {
-            circuit.completeFailure(error);
-            return successfulTelemetryDropResponse();
-        }
-    };
-}
-export function createOneShotOtlpTransport(options) {
-    return {
-        async send(data, timeoutMillis) {
-            if (!options.circuit.tryStart()) {
-                return { status: "success" };
-            }
-            const controller = new AbortController();
-            const timeout = setTimeout(() => controller.abort(), timeoutMillis);
-            timeout.unref?.();
+        if (!open) {
             try {
-                const response = await options.fetchImpl(options.url, {
-                    method: "POST",
-                    headers: {
-                        ...options.headers,
-                        "Content-Type": options.contentType,
-                    },
-                    body: Buffer.from(data),
-                    signal: controller.signal,
-                });
-                if (response.status < 200 || response.status >= 400) {
-                    throw new Error(`OTLP transport returned HTTP ${response.status}`);
-                }
-                options.circuit.completeSuccess();
-                return { status: "success" };
+                const response = await fetchImpl(url, options);
+                if (response.status >= 200 && response.status < 400)
+                    return response;
+                throw new Error(`PostHog transport returned HTTP ${response.status}`);
             }
             catch (error) {
-                // The exporter reports success after opening the shared circuit so
-                // OpenTelemetry processors do not relay optional telemetry failures
-                // through their global error handler.
-                options.circuit.completeFailure(error);
-                return { status: "success" };
+                open = true;
+                onTransportFailure(error);
             }
-            finally {
-                clearTimeout(timeout);
-            }
-        },
-        shutdown() { },
+        }
+        return new Response(null, { status: 204 });
     };
 }
-function createOneShotOtlpExporter(options) {
-    const metrics = createOtlpHttpExporterMetrics(options.componentType, options.metricsHelper, options.url, undefined);
-    const transport = createOneShotOtlpTransport(options);
-    return new OTLPExporterBase(createOtlpNetworkExportDelegate({
-        timeoutMillis: options.timeoutMillis,
-        concurrencyLimit: 1,
-        compression: "none",
-    }, options.serializer, metrics, transport));
-}
 function disableTelemetryAfterTransportFailure(error) {
     if (telemetryTransportFailed)
         return;
@@ -213,7 +131,6 @@ export function resolvePostHogTelemetryConfig(options = {}) {
         projectToken,
         distinctId: env.FEYNMAN_TELEMETRY_DISTINCT_ID?.trim() || getAnonymousDistinctId(options.home),
         appVersion: options.appVersion,
-        serviceName: options.serviceName ?? "feynman-cli",
     };
 }
 function normalizeTelemetryKey(key) {
@@ -262,16 +179,6 @@ function baseTelemetryProperties(config) {
         $process_person_profile: false,
     });
 }
-function toOtelAttributes(properties = {}) {
-    const normalized = normalizeTelemetryProperties(properties);
-    const attributes = {};
-    for (const [key, value] of Object.entries(normalized)) {
-        if (value === null)
-            continue;
-        attributes[key] = value;
-    }
-    return attributes;
-}
 export function stableTelemetryHash(value) {
     if (!value)
         return undefined;
@@ -289,13 +196,6 @@ export function telemetryErrorProperties(error) {
         error_message_hash: stableTelemetryHash(message),
     };
 }
-export function sanitizeTelemetryException(error) {
-    const properties = telemetryErrorProperties(error);
-    return {
-        name: String(properties.error_name ?? "unknown"),
-        message: `error_message_hash:${properties.error_message_hash ?? "unknown"}`,
-    };
-}
 export function initializePostHogTelemetry(options = {}) {
     if (telemetryInitialized)
         return activeConfig;
@@ -305,81 +205,22 @@ export function initializePostHogTelemetry(options = {}) {
     activeConfig = config;
     if (!config)
         return undefined;
-    try {
-        const resource = resourceFromAttributes({
-            [ATTR_SERVICE_NAME]: config.serviceName,
-            ...(config.appVersion ? { [ATTR_SERVICE_VERSION]: config.appVersion } : {}),
-        });
-        const circuit = createTelemetryTransportCircuitBreaker(disableTelemetryAfterTransportFailure);
-        const defaultTelemetryFetch = (url, fetchOptions) => fetch(url, fetchOptions);
-        const otlpFetch = options.otlpFetch ?? defaultTelemetryFetch;
-        tracerProvider = new NodeTracerProvider({
-            resource,
-            spanProcessors: [
-                new BatchSpanProcessor(createOneShotOtlpExporter({
-                    url: `${config.host}/i/v1/traces`,
-                    headers: { Authorization: `Bearer ${config.projectToken}` },
-                    contentType: "application/x-protobuf",
-                    fetchImpl: otlpFetch,
-                    circuit,
-                    timeoutMillis: 750,
-                    componentType: "otlp_http_span_exporter",
-                    serializer: ProtobufTraceSerializer,
-                    metricsHelper: TraceExporterMetricsHelper,
-                }), { scheduledDelayMillis: 250, exportTimeoutMillis: 3000 }),
-            ],
-        });
-        tracerProvider.register();
-        loggerProvider = new LoggerProvider({
-            resource,
-            processors: [
-                new BatchLogRecordProcessor({
-                    exporter: createOneShotOtlpExporter({
-                        url: `${config.host}/i/v1/logs`,
-                        headers: { Authorization: `Bearer ${config.projectToken}` },
-                        contentType: "application/json",
-                        fetchImpl: otlpFetch,
-                        circuit,
-                        timeoutMillis: 750,
-                        componentType: "otlp_http_log_exporter",
-                        serializer: JsonLogsSerializer,
-                        metricsHelper: LogsExporterMetricsHelper,
-                    }),
-                    scheduledDelayMillis: 250,
-                    exportTimeoutMillis: 3000,
-                }),
-            ],
-        });
-        logs.setGlobalLoggerProvider(loggerProvider);
-        const defaultPostHogFetch = (url, fetchOptions) => fetch(url, fetchOptions);
-        posthogClient = new PostHog(config.projectToken, {
-            host: config.host,
-            flushAt: 1,
-            flushInterval: 0,
-            isServer: false,
-            disableGeoip: true,
-            fetchRetryCount: 0,
-            fetch: createTelemetryCircuitBreakerFetch(options.posthogFetch ?? defaultPostHogFetch, disableTelemetryAfterTransportFailure, circuit),
-        });
-        posthogClient.on("error", () => {
-            if (process.env.FEYNMAN_DEBUG === "1" && !telemetryStartWarningPrinted) {
-                telemetryStartWarningPrinted = true;
-                process.stderr.write("[feynman] PostHog telemetry transport reported an error.\n");
-            }
-        });
-        return config;
-    }
-    catch (error) {
+    posthogClient = new PostHog(config.projectToken, {
+        host: config.host,
+        flushAt: 1,
+        flushInterval: 0,
+        isServer: false,
+        disableGeoip: true,
+        fetchRetryCount: 0,
+        fetch: createTelemetryCircuitBreakerFetch(options.posthogFetch ?? ((url, fetchOptions) => fetch(url, fetchOptions)), disableTelemetryAfterTransportFailure),
+    });
+    posthogClient.on("error", () => {
         if (process.env.FEYNMAN_DEBUG === "1" && !telemetryStartWarningPrinted) {
             telemetryStartWarningPrinted = true;
-            process.stderr.write(`[feynman] PostHog telemetry disabled after initialization failed (${error instanceof Error ? error.message : "unknown error"}).\n`);
+            process.stderr.write("[feynman] PostHog telemetry transport reported an error.\n");
         }
-        activeConfig = undefined;
-        posthogClient = undefined;
-        tracerProvider = undefined;
-        loggerProvider = undefined;
-        return undefined;
-    }
+    });
+    return config;
 }
 export function captureTelemetryEvent(event, properties = {}) {
     if (!activeConfig || !posthogClient)
@@ -405,90 +246,17 @@ export async function captureTelemetryEventImmediate(event, properties = {}) {
         },
     });
 }
-export function emitTelemetryLog(severityText, body, properties = {}) {
-    if (!activeConfig || !loggerProvider)
-        return;
-    const severityNumber = severityText === "error"
-        ? SeverityNumber.ERROR
-        : severityText === "warn"
-            ? SeverityNumber.WARN
-            : severityText === "debug"
-                ? SeverityNumber.DEBUG
-                : severityText === "trace"
-                    ? SeverityNumber.TRACE
-                    : SeverityNumber.INFO;
-    logs.getLogger("feynman").emit({
-        severityText,
-        severityNumber,
-        body,
-        attributes: {
-            ...toOtelAttributes(baseTelemetryProperties(activeConfig)),
-            ...toOtelAttributes(properties),
-        },
-    });
-}
-function createNoopSpan() {
-    return {
-        setAttributes() { },
-        recordException() { },
-        end() { },
-    };
-}
-export function startTelemetrySpan(name, properties = {}) {
-    if (!activeConfig || !tracerProvider)
-        return createNoopSpan();
-    const span = trace.getTracer("feynman").startSpan(name, {
-        attributes: {
-            ...toOtelAttributes(baseTelemetryProperties(activeConfig)),
-            ...toOtelAttributes(properties),
-        },
-    });
-    let ended = false;
-    return {
-        setAttributes(nextProperties) {
-            if (ended)
-                return;
-            span.setAttributes(toOtelAttributes(nextProperties));
-        },
-        recordException(error) {
-            if (ended)
-                return;
-            span.recordException(sanitizeTelemetryException(error));
-            span.setAttributes(toOtelAttributes(telemetryErrorProperties(error)));
-        },
-        end(status = "ok", nextProperties = {}) {
-            if (ended)
-                return;
-            ended = true;
-            if (Object.keys(nextProperties).length > 0) {
-                span.setAttributes(toOtelAttributes(nextProperties));
-            }
-            if (status === "error") {
-                span.setStatus({ code: SpanStatusCode.ERROR });
-            }
-            else {
-                span.setStatus({ code: SpanStatusCode.OK });
-            }
-            span.end();
-        },
-    };
-}
 export async function shutdownPostHogTelemetry() {
     const client = posthogClient;
-    const traces = tracerProvider;
-    const loggers = loggerProvider;
     posthogClient = undefined;
-    tracerProvider = undefined;
-    loggerProvider = undefined;
     activeConfig = undefined;
     telemetryInitialized = false;
     telemetryTransportFailed = false;
     telemetryNoticeThisProcess = undefined;
-    await Promise.allSettled([
-        client?.shutdown(3000),
-        traces?.shutdown(),
-        loggers?.shutdown(),
-    ]);
+    try {
+        await client?.shutdown(3000);
+    }
+    catch { }
 }
 function flagValue(args, flag) {
     const prefix = `${flag}=`;

package/extensions/research-tools/alpha.ts

@@ -86,7 +86,7 @@ export function registerAlphaTools(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "alpha_ask_paper",
 		label: "Alpha Ask Paper",
-		description: "Ask a targeted question about a paper. Uses AI to analyze the PDF and answer.",
+		description: "Ask a targeted question about an arXiv or alphaXiv paper. Uses AI to analyze the PDF and answer. DOI-only papers are not supported; read those with fetch_content on the open-access PDF or Europe PMC full text.",
 		parameters: Type.Object({
 			paper: Type.String({ description: "arXiv ID, arXiv URL, or alphaXiv URL." }),
 			question: Type.String({ description: "Question about the paper." }),

package/extensions/research-tools/science-database-openalex-exact.ts

@@ -1,4 +1,4 @@
-const MAX_EXACT_RECORDS = 500;
+const MAX_EXACT_RECORDS = 50;
 const REQUEST_TIMEOUT_MS = 25_000;
 const OPENALEX_BASE = "https://api.openalex.org";
 const OPEN_ABSTRACT_LICENSES = new Set(["cc-by", "cc-by-sa", "cc0", "public-domain"]);
@@ -461,9 +461,9 @@ async function fetchWorkById(workId: string): Promise<{
 	};
 }
 
-async function exactWorkSearch(query: string, commandQuery: string): Promise<Record<string, unknown>> {
+async function exactWorkSearch(query: string, commandQuery: string, defaultLimit?: number): Promise<Record<string, unknown>> {
 	const parsed = parseKeyValueQuery(commandQuery);
-	const maxRecords = safeExactLimit(numberValue(parsed.flags.max_records), 50);
+	const maxRecords = safeExactLimit(numberValue(parsed.flags.max_records), defaultLimit ?? 50);
 	const url = endpointPath("/works");
 	if (parsed.text) url.searchParams.set("search", parsed.text);
 	const filters: string[] = [];
@@ -518,12 +518,12 @@ async function exactGetWork(query: string, workId: string): Promise<Record<strin
 	}, "openalex_get_work", query, resolved.endpoints, resolved.credentialStatus);
 }
 
-async function exactCitations(query: string, commandQuery: string): Promise<Record<string, unknown>> {
+async function exactCitations(query: string, commandQuery: string, defaultLimit?: number): Promise<Record<string, unknown>> {
 	const parsed = parseKeyValueQuery(commandQuery);
 	const workInput = parsed.text;
 	if (!workInput) throw new Error("openalex_citations requires an OpenAlex work id or DOI.");
 	const resolved = await fetchWorkById(workInput);
-	const maxRecords = safeExactLimit(numberValue(parsed.flags.max_records), 50);
+	const maxRecords = safeExactLimit(numberValue(parsed.flags.max_records), defaultLimit ?? 50);
 	const url = endpointPath("/works");
 	url.searchParams.set("filter", `cites:${resolved.workId}`);
 	const sort = exactSearchSort(parsed.flags.sort ?? "cited_by_count", false);
@@ -545,11 +545,11 @@ async function exactCitations(query: string, commandQuery: string): Promise<Reco
 	}, "openalex_citations", query, [...resolved.endpoints, result.endpoint], result.credentialStatus);
 }
 
-async function exactReferences(query: string, commandQuery: string): Promise<Record<string, unknown>> {
+async function exactReferences(query: string, commandQuery: string, defaultLimit?: number): Promise<Record<string, unknown>> {
 	const parsed = parseKeyValueQuery(commandQuery);
 	if (!parsed.text) throw new Error("openalex_references requires an OpenAlex work id or DOI.");
 	const resolved = await fetchWorkById(parsed.text);
-	const maxRecords = safeExactLimit(numberValue(parsed.flags.max_records), 100);
+	const maxRecords = safeExactLimit(numberValue(parsed.flags.max_records), defaultLimit ?? 100);
 	const referenceIds = arrayValue(resolved.payload.referenced_works).map(shortOpenAlexId).filter((id): id is string => Boolean(id));
 	const selected = referenceIds.slice(0, maxRecords);
 	const endpoints = [...resolved.endpoints];
@@ -581,10 +581,10 @@ async function exactReferences(query: string, commandQuery: string): Promise<Rec
 	}, "openalex_references", query, endpoints, credentialStatus);
 }
 
-async function exactSearchAuthors(query: string, commandQuery: string): Promise<Record<string, unknown>> {
+async function exactSearchAuthors(query: string, commandQuery: string, defaultLimit?: number): Promise<Record<string, unknown>> {
 	const parsed = parseKeyValueQuery(commandQuery);
 	if (!parsed.text) throw new Error("openalex_search_authors requires a name query.");
-	const maxRecords = safeExactLimit(numberValue(parsed.flags.max_records), 25);
+	const maxRecords = safeExactLimit(numberValue(parsed.flags.max_records), defaultLimit ?? 25);
 	const url = endpointPath("/authors");
 	url.searchParams.set("search", parsed.text);
 	url.searchParams.set("per-page", String(Math.min(maxRecords, 200)));
@@ -625,7 +625,7 @@ async function exactGetAuthor(query: string, commandQuery: string): Promise<Reco
 	}, "openalex_get_author", query, [result.endpoint, works.endpoint], works.credentialStatus);
 }
 
-async function exactVenueInfo(query: string, commandQuery: string): Promise<Record<string, unknown>> {
+async function exactVenueInfo(query: string, commandQuery: string, defaultLimit?: number): Promise<Record<string, unknown>> {
 	const parsed = parseKeyValueQuery(commandQuery);
 	const venue = parsed.text;
 	if (!venue) throw new Error("openalex_venue_info requires a source id, ISSN, or venue name.");
@@ -640,7 +640,7 @@ async function exactVenueInfo(query: string, commandQuery: string): Promise<Reco
 			records: [row],
 		}, "openalex_venue_info", query, [result.endpoint], result.credentialStatus);
 	}
-	const maxRecords = safeExactLimit(numberValue(parsed.flags.max_records), 10);
+	const maxRecords = safeExactLimit(numberValue(parsed.flags.max_records), defaultLimit ?? 10);
 	const url = endpointPath("/sources");
 	url.searchParams.set("search", venue);
 	url.searchParams.set("per-page", String(Math.min(maxRecords, 200)));
@@ -657,15 +657,15 @@ async function exactVenueInfo(query: string, commandQuery: string): Promise<Reco
 	}, "openalex_venue_info", query, [result.endpoint], result.credentialStatus);
 }
 
-export async function searchExactOpenAlex(query: string): Promise<Record<string, unknown> | undefined> {
+export async function searchExactOpenAlex(query: string, defaultLimit?: number): Promise<Record<string, unknown> | undefined> {
 	const command = exactCommand(query);
 	if (!command) return undefined;
-	if (command.name === "openalex_search_works") return exactWorkSearch(query, command.rest);
+	if (command.name === "openalex_search_works") return exactWorkSearch(query, command.rest, defaultLimit);
 	if (command.name === "openalex_get_work") return exactGetWork(query, command.rest);
-	if (command.name === "openalex_citations") return exactCitations(query, command.rest);
-	if (command.name === "openalex_references") return exactReferences(query, command.rest);
-	if (command.name === "openalex_search_authors") return exactSearchAuthors(query, command.rest);
+	if (command.name === "openalex_citations") return exactCitations(query, command.rest, defaultLimit);
+	if (command.name === "openalex_references") return exactReferences(query, command.rest, defaultLimit);
+	if (command.name === "openalex_search_authors") return exactSearchAuthors(query, command.rest, defaultLimit);
 	if (command.name === "openalex_get_author") return exactGetAuthor(query, command.rest);
-	if (command.name === "openalex_venue_info") return exactVenueInfo(query, command.rest);
+	if (command.name === "openalex_venue_info") return exactVenueInfo(query, command.rest, defaultLimit);
 	return undefined;
 }

package/extensions/research-tools/science-database-openalex.ts

@@ -354,7 +354,7 @@ async function resolveDoiWork(doiWorkId: string): Promise<{
 export async function searchOpenAlex(params: SearchParams): Promise<Record<string, unknown>> {
 	const query = cleanQuery(params.query);
 	const limit = safeLimit(params.limit);
-	const exact = await searchExactOpenAlex(query);
+	const exact = await searchExactOpenAlex(query, limit);
 	if (exact) return exact;
 	if (/^rate-limit$/i.test(query)) {
 		if (!openAlexApiKey()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@companion-ai/feynman",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "Research-first CLI agent built on Pi and alphaXiv",
   "license": "MIT",
   "type": "module",
@@ -42,7 +42,7 @@
     "prepack": "node ./scripts/clean-publish-artifacts.mjs && npm run build",
     "start": "tsx src/index.ts",
     "start:dist": "node ./bin/feynman.js",
-    "test": "node --import tsx --test --test-concurrency=1 tests/*.test.ts",
+    "test": "node --import tsx --import ./tests/isolate-tmpdir.ts --test --test-concurrency=1 tests/*.test.ts",
     "typecheck": "tsc --noEmit",
     "architecture:check": "node ./scripts/check-architecture.mjs"
   },
@@ -79,17 +79,8 @@
   "dependencies": {
     "@clack/prompts": "^1.7.0",
     "@companion-ai/alpha-hub": "0.1.6",
-    "@earendil-works/pi-ai": "0.87.1",
-    "@earendil-works/pi-coding-agent": "0.87.1",
-    "@opentelemetry/api": "^1.9.1",
-    "@opentelemetry/api-logs": "^0.222.0",
-    "@opentelemetry/otlp-exporter-base": "^0.222.0",
-    "@opentelemetry/otlp-transformer": "^0.222.0",
-    "@opentelemetry/resources": "^2.11.0",
-    "@opentelemetry/sdk-logs": "^0.222.0",
-    "@opentelemetry/sdk-trace-base": "^2.11.0",
-    "@opentelemetry/sdk-trace-node": "^2.11.0",
-    "@opentelemetry/semantic-conventions": "^1.43.0",
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
     "fast-xml-parser": "5.11.1",
     "pi-btw": "0.6.0",
     "pi-docparser": "4.0.0",

package/prompts/audit.md

@@ -4,17 +4,6 @@ args: <item>
 section: Research Workflows
 topLevelCli: true
 ---
-## Tool Discipline (Read First)
-
-Tool names are literal. Use only tools visible in the current tool set.
-
-- Search with `web_search`; do not call `search_web`, `google_search`, `google:search`, `search_google`, or `WebSearch`.
-- Fetch URLs with `fetch_content`; do not call bare `fetch`, `WebFetch`, `read_url_content`, or pass an array as `url`. Use `urls` for multiple URLs when the tool supports it.
-- Use visible Feynman alpha tools such as `alpha_search` when present. For shell access, call `feynman alpha ...`; do not call the user's bare global `alpha` binary.
-- To ask the user a question, write plain chat text and wait for the next user message. Do not call `ask_user_question`, `ask_user`, `ask_followup_question`, or `user_choice`.
-- Do not use `Task` as an agent dispatcher. Use only the visible `subagent` tool when it exists.
-- If a tool returns `Tool not found` or `Invalid URL`, do not retry the same invalid call. Map to a canonical visible tool and valid arguments, or record the capability as blocked.
-
 Audit the paper and codebase for: $@
 
 Derive a short slug from the audit target (lowercase, hyphens, no filler words, ≤5 words). Use this slug for all files in this run.

package/prompts/autoresearch.md

@@ -4,17 +4,6 @@ args: <idea>
 section: Research Workflows
 topLevelCli: true
 ---
-## Tool Discipline (Read First)
-
-Tool names are literal. Use only tools visible in the current tool set.
-
-- Search with `web_search`; do not call `search_web`, `google_search`, `google:search`, `search_google`, or `WebSearch`.
-- Fetch URLs with `fetch_content`; do not call bare `fetch`, `WebFetch`, `read_url_content`, or pass an array as `url`. Use `urls` for multiple URLs when the tool supports it.
-- Use visible Feynman alpha tools such as `alpha_search` when present. For shell access, call `feynman alpha ...`; do not call the user's bare global `alpha` binary.
-- To ask the user a question, write plain chat text and wait for the next user message. Do not call `ask_user_question`, `ask_user`, `ask_followup_question`, or `user_choice`.
-- Do not use `Task` as an agent dispatcher. Use only the visible `subagent` tool when it exists.
-- If a tool returns `Tool not found` or `Invalid URL`, do not retry the same invalid call. Map to a canonical visible tool and valid arguments, or record the capability as blocked.
-
 Start an autoresearch optimization loop for: $@
 
 This command runs a bounded foreground research experiment loop using the visible tools in this session.
@@ -66,14 +55,6 @@ After the baseline and after meaningful iteration milestones, append a concise e
 
 When reporting results, include every configuration tried from `autoresearch.jsonl` (kept, reverted, and failed) with its metric. Do not claim an effect from the single most favorable setting; state how the result varies across all tried settings and seeds.
 
-## Optional tools
-
-Use these only when they are visible in the current tool set:
-
-- `init_experiment` - one-time session config (name, metric, unit, direction)
-- `run_experiment` - run the benchmark command, capture output and wall-clock time
-- `log_experiment` - record the benchmark result, evidence, and decision in the autoresearch log
-
 ## Subcommands
 
 - `/autoresearch <text>` — start or resume the loop

package/prompts/compare.md

@@ -4,17 +4,6 @@ args: <topic>
 section: Research Workflows
 topLevelCli: true
 ---
-## Tool Discipline (Read First)
-
-Tool names are literal. Use only tools visible in the current tool set.
-
-- Search with `web_search`; do not call `search_web`, `google_search`, `google:search`, `search_google`, or `WebSearch`.
-- Fetch URLs with `fetch_content`; do not call bare `fetch`, `WebFetch`, `read_url_content`, or pass an array as `url`. Use `urls` for multiple URLs when the tool supports it.
-- Use visible Feynman alpha tools such as `alpha_search` when present. For shell access, call `feynman alpha ...`; do not call the user's bare global `alpha` binary.
-- To ask the user a question, write plain chat text and wait for the next user message. Do not call `ask_user_question`, `ask_user`, `ask_followup_question`, or `user_choice`.
-- Do not use `Task` as an agent dispatcher. Use only the visible `subagent` tool when it exists.
-- If a tool returns `Tool not found` or `Invalid URL`, do not retry the same invalid call. Map to a canonical visible tool and valid arguments, or record the capability as blocked.
-
 Compare sources for: $@
 
 Derive a short slug from the comparison topic (lowercase, hyphens, no filler words, ≤5 words). Use this slug for all files in this run.
@@ -23,7 +12,7 @@ Requirements:
 - Before starting, outline the comparison plan: which sources to compare, which dimensions to evaluate, expected output structure. Write the plan to `outputs/.plans/<slug>.md`. Briefly summarize the plan to the user and continue immediately. Do not ask for confirmation or wait for a proceed response unless the user explicitly requested plan review.
 - Use the `researcher` subagent to gather source material when the comparison set is broad, and the `verifier` subagent to verify sources and add inline citations to the final matrix.
 - Build a comparison matrix covering: source, key claim, evidence type, caveats, confidence.
-- Generate charts only when a chart tool is visible and the comparison involves quantitative metrics; otherwise include a source-backed table or chart specification. Use Mermaid for method or architecture comparisons when the structure is source-supported.
+- Use a Markdown table for quantitative metrics and Mermaid for method or architecture comparisons when the structure is source-supported.
 - Distinguish agreement, disagreement, and uncertainty clearly.
 - Save exactly one comparison to `outputs/<slug>-comparison.md`.
 - End with a `Sources` section containing direct URLs for every source used.

package/prompts/deepresearch.md

@@ -4,22 +4,8 @@ args: <topic>
 section: Research Workflows
 topLevelCli: true
 ---
-## Tool Discipline (Read First)
-
-Tool names are literal. Use only tools visible in the current tool set.
-
-- Search with `web_search`; do not call `search_web`, `google_search`, `google:search`, `search_google`, or `WebSearch`.
-- Fetch URLs with `fetch_content`; do not call bare `fetch`, `WebFetch`, `read_url_content`, or pass an array as `url`. Use `urls` for multiple URLs when the tool supports it.
-- Use visible Feynman alpha tools such as `alpha_search` when present. For shell access, call `feynman alpha ...`; do not call the user's bare global `alpha` binary.
-- To ask the user a question, write plain chat text and wait for the next user message. Do not call `ask_user_question`, `ask_user`, `ask_followup_question`, or `user_choice`.
-- Do not use `Task` as an agent dispatcher. Use only the visible `subagent` tool when it exists.
-- If a tool returns `Tool not found` or `Invalid URL`, do not retry the same invalid call. Map to a canonical visible tool and valid arguments, or record the capability as blocked.
-
 Run deep research for: $@
 
-This is an execution request, not a request to explain or implement the workflow instructions.
-Execute the workflow. Do not answer by describing the protocol, do not explain these instructions, and do not restate the protocol. Your first actions should be tool calls that create directories and write the plan artifact.
-
 ## Required Artifacts
 
 Derive a short slug from the topic: lowercase, hyphenated, no filler words, at most 5 words.
@@ -45,8 +31,6 @@ Create `outputs/.plans/<slug>.md` immediately. The plan must include:
 
 Make the scale decision before assigning owners in the plan. If the topic is a narrow "what is X" explainer, the plan must use lead-owned direct search tasks only; do not allocate researcher subagents in the task ledger.
 
-Also save the plan with `memory_remember` using key `deepresearch.<slug>.plan` if that tool is available. If it is not available, continue without it.
-
 After writing the plan, stop and ask for explicit confirmation before gathering evidence. Summarize the plan briefly and ask:
 
 `Proceed with this deep research plan? Reply "yes" to continue, or tell me what to change.`
@@ -69,9 +53,7 @@ Use subagents only when decomposition clearly helps:
 
 ## Step 3: Gather Evidence
 
-Use only tool names visible in the current tool set. For web search, call `web_search`; never call `google:search`, `google_search`, or `search_google`.
-
-Avoid crash-prone PDF parsing in this workflow. Do not call `alpha_get_paper` and do not fetch `.pdf` URLs unless the user explicitly asks for PDF extraction. Prefer paper metadata, abstracts, HTML pages, official docs, and web snippets. If only a PDF exists, cite the PDF URL from search metadata and mark full-text PDF parsing as blocked instead of fetching it.
+Prefer abstracts, HTML pages, official docs, and paper metadata. Read full text only for the few papers the conclusions depend on.
 
 If direct search was chosen:
 - Skip researcher spawning entirely.
@@ -88,7 +70,6 @@ If subagents were chosen:
 - Use only supported `subagent` keys. Do not add extra keys such as `artifacts` unless the tool schema explicitly exposes them.
 - Use one async `workflowScript` with `await runs.all(...)` for parallel evidence gathering. Each item needs a unique stable `key`, plus its agent, short task, and output path. Set `globalConcurrencyLimit: 4` on the outer call.
 - Read the ordered result array and record each child's `ok`, error, and returned output/artifact paths. Ordinary child failures are collected by `runs.all`; validation or infrastructure failure can still fail the workflow. Do not assume every output exists.
-- Do not name exact tool commands in subagent tasks unless those tool names are visible in the current tool set.
 - Prefer broad guidance such as "use paper search and web search"; if a PDF parser or paper fetch fails, the researcher must continue from metadata, abstracts, and web sources and mark PDF parsing as blocked.
 
 Example shape:
@@ -169,8 +150,6 @@ Consume the review completion result and locate its returned output before proce
 
 When applying reviewer fixes, do not issue one giant `edit` tool call with many replacements. Use small localized edits only for 1-3 simple corrections. For section rewrites, table rewrites, or more than 3 substantive fixes, read the cited draft and write a corrected full file to `outputs/.drafts/<slug>-revised.md` instead.
 
-After applying reviewer, verifier, audit, or PI-style fixes, run an explicit on-disk verification before saying the fixes landed. Use `rg`, `grep`, `diff`, `wc`, `stat`, or a targeted read to prove the old unsupported wording is gone and the replacement wording exists. If an `edit` or `write` tool call fails, do not describe the fix as applied; record the failure in the plan/provenance, retry with a smaller edit or a full corrected file, and verify again. Provenance may only say an issue was fixed when this post-edit verification passed.
-
 The final candidate is `outputs/.drafts/<slug>-revised.md` if it exists; otherwise it is `outputs/.drafts/<slug>-cited.md`.
 
 ## Step 7: Deliver
@@ -196,6 +175,4 @@ Write provenance next to it as `<slug>.provenance.md`:
 
 Before responding, verify on disk that all required artifacts exist. If verification could not be completed, set `Verification: BLOCKED` or `PASS WITH NOTES` and list the missing checks.
 
-Before responding, also verify that any fixes claimed in the provenance are reflected in the final candidate. If a fix removed a phrase, number, source, or claim, run a targeted `rg`/`grep` check for the removed content and a second check for the corrected content. Do not claim "all patches applied", "all checks pass", or "fixed" unless these commands or reads succeed.
-
 Final response should be brief: link the final file, provenance file, and any blocked checks.

package/prompts/draft.md

@@ -4,17 +4,6 @@ args: <topic>
 section: Research Workflows
 topLevelCli: true
 ---
-## Tool Discipline (Read First)
-
-Tool names are literal. Use only tools visible in the current tool set.
-
-- Search with `web_search`; do not call `search_web`, `google_search`, `google:search`, `search_google`, or `WebSearch`.
-- Fetch URLs with `fetch_content`; do not call bare `fetch`, `WebFetch`, `read_url_content`, or pass an array as `url`. Use `urls` for multiple URLs when the tool supports it.
-- Use visible Feynman alpha tools such as `alpha_search` when present. For shell access, call `feynman alpha ...`; do not call the user's bare global `alpha` binary.
-- To ask the user a question, write plain chat text and wait for the next user message. Do not call `ask_user_question`, `ask_user`, `ask_followup_question`, or `user_choice`.
-- Do not use `Task` as an agent dispatcher. Use only the visible `subagent` tool when it exists.
-- If a tool returns `Tool not found` or `Invalid URL`, do not retry the same invalid call. Map to a canonical visible tool and valid arguments, or record the capability as blocked.
-
 Write a paper-style draft for: $@
 
 Derive a short slug from the topic (lowercase, hyphens, no filler words, ≤5 words). Use this slug for all files in this run.
@@ -25,7 +14,7 @@ Requirements:
 - Include at minimum: title, abstract, problem statement, related work, method or synthesis, evidence or experiments, limitations, conclusion.
 - Use clean Markdown with LaTeX where equations materially help.
 - Follow the system prompt's provenance rules for all results, figures, charts, images, tables, benchmarks, and quantitative comparisons. If evidence is missing, leave a placeholder or proposed experimental plan instead of claiming an outcome.
-- Generate charts only when a chart tool is visible and the underlying source-backed quantitative data, benchmarks, or comparisons support the visual; otherwise write a chart specification or table. Use Mermaid for architectures and pipelines only when the structure is supported by sources. Every figure, chart spec, or table needs provenance.
+- Use Markdown tables for quantitative comparisons and Mermaid for architectures and pipelines. Plot only source-backed data, and save the plotting script next to the draft. Every figure or table needs provenance.
 - Before delivery, sweep the draft for any claim that sounds stronger than its support. Mark tentative results as tentative and remove unsupported numerics instead of letting the verifier discover them later.
 - Save exactly one draft to `papers/<slug>.md`.
 - End with a `Sources` appendix with direct URLs for all primary references.

package/prompts/lit.md

@@ -4,17 +4,6 @@ args: <topic-or-lab-or-author>
 section: Research Workflows
 topLevelCli: true
 ---
-## Tool Discipline (Read First)
-
-Tool names are literal. Use only tools visible in the current tool set.
-
-- Search with `web_search`; do not call `search_web`, `google_search`, `google:search`, `search_google`, or `WebSearch`.
-- Fetch URLs with `fetch_content`; do not call bare `fetch`, `WebFetch`, `read_url_content`, or pass an array as `url`. Use `urls` for multiple URLs when the tool supports it.
-- Use visible Feynman alpha tools such as `alpha_search` when present. For shell access, call `feynman alpha ...`; do not call the user's bare global `alpha` binary.
-- To ask the user a question, write plain chat text and wait for the next user message. Do not call `ask_user_question`, `ask_user`, `ask_followup_question`, or `user_choice`.
-- Do not use `Task` as an agent dispatcher. Use only the visible `subagent` tool when it exists.
-- If a tool returns `Tool not found` or `Invalid URL`, do not retry the same invalid call. Map to a canonical visible tool and valid arguments, or record the capability as blocked.
-
 Investigate the following topic, lab, PI, or author as a literature review: $@
 
 Derive a short slug from the topic (lowercase, hyphens, no filler words, ≤5 words). Use this slug for all files in this run.
@@ -24,7 +13,7 @@ Derive a short slug from the topic (lowercase, hyphens, no filler words, ≤5 wo
 1. **Plan** — Outline the scope: key questions, source types to search (papers, web, repos), time period, expected sections, and a small task ledger plus verification log. When the input appears to name a lab, PI, author, institution lab page, or author profile, run the review as a publication-corpus review: find the lab/author identity first, collect the reachable publication list, then map the research trajectory across that corpus. Write the plan to `outputs/.plans/<slug>.md`. Briefly summarize the plan to the user and continue immediately in the same turn with the next tool call; never end a turn with a message that only announces what you will do next. Do not ask for confirmation or wait for a proceed response unless the user explicitly requested plan review.
    - When updating the plan ledger later, keep edits small and valid. If an `edit` tool call fails with a JSON parse error or the replacement would require embedding a large markdown block, rewrite the full corrected plan file with the file-writing tool instead, then continue to final artifact/provenance verification.
 2. **Gather** — Use the `researcher` subagent when the sweep is wide enough to benefit from delegated paper triage before synthesis. For narrow topics, search directly. Researcher outputs go to `<slug>-research-*.md`. For publication-corpus reviews, the lead agent owns identity resolution and writes `notes/<slug>-publications.md` with reachable titles, years, venues, URLs/DOIs, and gaps before delegating trajectory synthesis. Prefer lab publication pages, author profiles, arXiv/OpenReview/Semantic Scholar pages, and paper search results that expose stable source URLs. Do not silently skip assigned questions; mark them `done`, `blocked`, or `superseded`.
-3. **Synthesize** — Separate consensus, disagreements, and open questions. For publication-corpus reviews, also identify 3-5 research trajectories and the 3-5 papers that most changed the corpus direction; rank them by contrastive originality, methodology strength, and relationship to prior art rather than by author prestige alone. When useful, propose concrete next experiments or follow-up reading. Generate charts only when a chart tool is visible and the data is source-backed; otherwise include a chart specification or comparison table. Use Mermaid diagrams for taxonomies, method pipelines, or lab trajectory maps when the structure is source-supported and changes the reader's research decision. Keep the output to research evidence, source coverage, and next research decisions; do not create non-research operational artifacts from a literature review run.
+3. **Synthesize** — Separate consensus, disagreements, and open questions. For publication-corpus reviews, also identify 3-5 research trajectories and the 3-5 papers that most changed the corpus direction; rank them by contrastive originality, methodology strength, and relationship to prior art rather than by author prestige alone. When useful, propose concrete next experiments or follow-up reading. Use Mermaid diagrams for taxonomies, method pipelines, or lab trajectory maps when the structure is source-supported and changes the reader's research decision. Keep the output to research evidence, source coverage, and next research decisions; do not create non-research operational artifacts from a literature review run.
 4. **Cite** — Spawn the `verifier` agent to add inline citations and verify every source URL in the draft.
 5. **Verify** — Spawn the `reviewer` agent to check the cited draft for unsupported claims, logical gaps, zombie sections, and single-source critical findings. Fix FATAL issues before delivering. Note MAJOR issues in Open Questions. If FATAL issues were found, run one more verification pass after the fixes.
 6. **Deliver** — Save the final literature review to `outputs/<slug>.md`. Write a provenance record alongside it as `outputs/<slug>.provenance.md` listing: date, sources consulted vs. accepted vs. rejected, verification status, and intermediate research files used; for publication-corpus reviews, include the publication-log path and unresolved corpus gaps. Before you stop, verify on disk that both files exist; do not stop at an intermediate cited draft alone.

package/prompts/log.md

@@ -3,17 +3,6 @@ description: Write a durable session log with completed work, findings, open que
 section: Project & Session
 topLevelCli: true
 ---
-## Tool Discipline (Read First)
-
-Tool names are literal. Use only tools visible in the current tool set.
-
-- Search with `web_search`; do not call `search_web`, `google_search`, `google:search`, `search_google`, or `WebSearch`.
-- Fetch URLs with `fetch_content`; do not call bare `fetch`, `WebFetch`, `read_url_content`, or pass an array as `url`. Use `urls` for multiple URLs when the tool supports it.
-- Use visible Feynman alpha tools such as `alpha_search` when present. For shell access, call `feynman alpha ...`; do not call the user's bare global `alpha` binary.
-- To ask the user a question, write plain chat text and wait for the next user message. Do not call `ask_user_question`, `ask_user`, `ask_followup_question`, or `user_choice`.
-- Do not use `Task` as an agent dispatcher. Use only the visible `subagent` tool when it exists.
-- If a tool returns `Tool not found` or `Invalid URL`, do not retry the same invalid call. Map to a canonical visible tool and valid arguments, or record the capability as blocked.
-
 Write a session log for the current research work.
 
 Requirements:

package/prompts/recipe.md

@@ -4,23 +4,10 @@ args: <task-or-paper>
 section: Research Workflows
 topLevelCli: true
 ---
-## Tool Discipline (Read First)
-
-Tool names are literal. Use only tools visible in the current tool set.
-
-- Search with `web_search`; do not call `search_web`, `google_search`, `google:search`, `search_google`, or `WebSearch`.
-- Fetch URLs with `fetch_content`; do not call bare `fetch`, `WebFetch`, `read_url_content`, or pass an array as `url`. Use `urls` for multiple URLs when the tool supports it.
-- Use visible Feynman alpha tools such as `alpha_search` when present. For shell access, call `feynman alpha ...`; do not call the user's bare global `alpha` binary.
-- To ask the user a question, write plain chat text and wait for the next user message. Do not call `ask_user_question`, `ask_user`, `ask_followup_question`, or `user_choice`.
-- Do not use `Task` as an agent dispatcher. Use only the visible `subagent` tool when it exists.
-- If a tool returns `Tool not found` or `Invalid URL`, do not retry the same invalid call. Map to a canonical visible tool and valid arguments, or record the capability as blocked.
-
 Find implementable ML training recipes for: $@
 
 Derive a short slug from the task (lowercase, hyphens, no filler words, ≤5 words). Use this slug for all files in this run.
 
-This is an execution request, not a request to explain the workflow. Continue immediately.
-
 ## Required artifacts
 
 - `outputs/.plans/<slug>-recipe.md`

package/prompts/replicate.md

@@ -4,17 +4,6 @@ args: <paper>
 section: Research Workflows
 topLevelCli: true
 ---
-## Tool Discipline (Read First)
-
-Tool names are literal. Use only tools visible in the current tool set.
-
-- Search with `web_search`; do not call `search_web`, `google_search`, `google:search`, `search_google`, or `WebSearch`.
-- Fetch URLs with `fetch_content`; do not call bare `fetch`, `WebFetch`, `read_url_content`, or pass an array as `url`. Use `urls` for multiple URLs when the tool supports it.
-- Use visible Feynman alpha tools such as `alpha_search` when present. For shell access, call `feynman alpha ...`; do not call the user's bare global `alpha` binary.
-- To ask the user a question, write plain chat text and wait for the next user message. Do not call `ask_user_question`, `ask_user`, `ask_followup_question`, or `user_choice`.
-- Do not use `Task` as an agent dispatcher. Use only the visible `subagent` tool when it exists.
-- If a tool returns `Tool not found` or `Invalid URL`, do not retry the same invalid call. Map to a canonical visible tool and valid arguments, or record the capability as blocked.
-
 Design a replication plan for: $@
 
 ## Workflow

package/prompts/review.md

@@ -4,23 +4,10 @@ args: <artifact>
 section: Research Workflows
 topLevelCli: true
 ---
-## Tool Discipline (Read First)
-
-Tool names are literal. Use only tools visible in the current tool set.
-
-- Search with `web_search`; do not call `search_web`, `google_search`, `google:search`, `search_google`, or `WebSearch`.
-- Fetch URLs with `fetch_content`; do not call bare `fetch`, `WebFetch`, `read_url_content`, or pass an array as `url`. Use `urls` for multiple URLs when the tool supports it.
-- Use visible Feynman alpha tools such as `alpha_search` when present. For shell access, call `feynman alpha ...`; do not call the user's bare global `alpha` binary.
-- To ask the user a question, write plain chat text and wait for the next user message. Do not call `ask_user_question`, `ask_user`, `ask_followup_question`, or `user_choice`.
-- Do not use `Task` as an agent dispatcher. Use only the visible `subagent` tool when it exists.
-- If a tool returns `Tool not found` or `Invalid URL`, do not retry the same invalid call. Map to a canonical visible tool and valid arguments, or record the capability as blocked.
-
 Review this AI research artifact: $@
 
 Derive a short slug from the artifact name (lowercase, hyphens, no filler words, ≤5 words). Use this slug for all files in this run.
 
-This is an execution request, not a request to explain or implement the workflow instructions. Carry out the workflow with tools and durable files. Do not answer by describing the protocol, saying what you would do, or stopping after a plan.
-
 Do not ask for confirmation. Briefly summarize the plan to the user and continue immediately unless the user explicitly asked to review the plan first.
 
 Required artifacts:

package/prompts/summarize.md

@@ -4,17 +4,6 @@ args: <source> [--window-size <chars>] [--overlap <chars>] [--tier1-threshold <c
 section: Research Workflows
 topLevelCli: true
 ---
-## Tool Discipline (Read First)
-
-Tool names are literal. Use only tools visible in the current tool set.
-
-- Search with `web_search`; do not call `search_web`, `google_search`, `google:search`, `search_google`, or `WebSearch`.
-- Fetch URLs with `fetch_content`; do not call bare `fetch`, `WebFetch`, `read_url_content`, or pass an array as `url`. Use `urls` for multiple URLs when the tool supports it.
-- Use visible Feynman alpha tools such as `alpha_search` when present. For shell access, call `feynman alpha ...`; do not call the user's bare global `alpha` binary.
-- To ask the user a question, write plain chat text and wait for the next user message. Do not call `ask_user_question`, `ask_user`, `ask_followup_question`, or `user_choice`.
-- Do not use `Task` as an agent dispatcher. Use only the visible `subagent` tool when it exists.
-- If a tool returns `Tool not found` or `Invalid URL`, do not retry the same invalid call. Map to a canonical visible tool and valid arguments, or record the capability as blocked.
-
 Summarize the following research source: $@
 
 Derive a short slug from the source filename or URL domain (lowercase, hyphens, no filler words, ≤5 words — e.g. `attention-is-all-you-need`). Use this slug for all files in this run.
@@ -27,15 +16,12 @@ Tier 1 (below the Tier-1 threshold) is a deliberate exception: direct injection
 
 ## Runtime knobs (context-window controls)
 
-Support both inline flags and environment variables so users can tune context-window behavior per run or globally.
-
-- `--window-size <chars>` or `FEYNMAN_SUMMARIZE_WINDOW_CHARS` (default: `6000`)
-- `--overlap <chars>` or `FEYNMAN_SUMMARIZE_OVERLAP_CHARS` (default: `500`)
-- `--tier1-threshold <chars>` or `FEYNMAN_SUMMARIZE_TIER1_THRESHOLD` (default: `8000`)
-- `--tier2-threshold <chars>` or `FEYNMAN_SUMMARIZE_TIER2_THRESHOLD` (default: `60000`)
+- `--window-size <chars>` (default: `6000`)
+- `--overlap <chars>` (default: `500`)
+- `--tier1-threshold <chars>` (default: `8000`)
+- `--tier2-threshold <chars>` (default: `60000`)
 
 Rules:
-- Inline flags override environment variables.
 - Validate `window-size > overlap` and `tier1-threshold < tier2-threshold`; if invalid, stop and report a clear configuration error.
 - Log resolved values once per run: `[summarize] config window=<w> overlap=<o> tier1=<t1> tier2=<t2>`.