@companion-ai/feynman 0.2.0

package/dist/bootstrap/sync.js

@@ -0,0 +1,98 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+import { getBootstrapStatePath } from "../config/paths.js";
+function sha256(text) {
+    return createHash("sha256").update(text).digest("hex");
+}
+function readBootstrapState(path) {
+    if (!existsSync(path)) {
+        return { version: 1, files: {} };
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        return {
+            version: 1,
+            files: parsed.files && typeof parsed.files === "object" ? parsed.files : {},
+        };
+    }
+    catch {
+        return { version: 1, files: {} };
+    }
+}
+function writeBootstrapState(path, state) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+function listFiles(root) {
+    if (!existsSync(root)) {
+        return [];
+    }
+    const files = [];
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        const path = resolve(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...listFiles(path));
+            continue;
+        }
+        if (entry.isFile()) {
+            files.push(path);
+        }
+    }
+    return files.sort();
+}
+function syncManagedFiles(sourceRoot, targetRoot, state, result) {
+    for (const sourcePath of listFiles(sourceRoot)) {
+        const key = relative(sourceRoot, sourcePath);
+        const targetPath = resolve(targetRoot, key);
+        const sourceText = readFileSync(sourcePath, "utf8");
+        const sourceHash = sha256(sourceText);
+        const previous = state.files[key];
+        mkdirSync(dirname(targetPath), { recursive: true });
+        if (!existsSync(targetPath)) {
+            writeFileSync(targetPath, sourceText, "utf8");
+            state.files[key] = {
+                lastAppliedSourceHash: sourceHash,
+                lastAppliedTargetHash: sourceHash,
+            };
+            result.copied.push(key);
+            continue;
+        }
+        const currentTargetText = readFileSync(targetPath, "utf8");
+        const currentTargetHash = sha256(currentTargetText);
+        if (currentTargetHash === sourceHash) {
+            state.files[key] = {
+                lastAppliedSourceHash: sourceHash,
+                lastAppliedTargetHash: currentTargetHash,
+            };
+            continue;
+        }
+        if (!previous) {
+            result.skipped.push(key);
+            continue;
+        }
+        if (currentTargetHash !== previous.lastAppliedTargetHash) {
+            result.skipped.push(key);
+            continue;
+        }
+        writeFileSync(targetPath, sourceText, "utf8");
+        state.files[key] = {
+            lastAppliedSourceHash: sourceHash,
+            lastAppliedTargetHash: sourceHash,
+        };
+        result.updated.push(key);
+    }
+}
+export function syncBundledAssets(appRoot, agentDir) {
+    const statePath = getBootstrapStatePath();
+    const state = readBootstrapState(statePath);
+    const result = {
+        copied: [],
+        updated: [],
+        skipped: [],
+    };
+    syncManagedFiles(resolve(appRoot, ".feynman", "themes"), resolve(agentDir, "themes"), state, result);
+    syncManagedFiles(resolve(appRoot, ".feynman", "agents"), resolve(agentDir, "agents"), state, result);
+    writeBootstrapState(statePath, state);
+    return result;
+}

package/dist/cli.js

@@ -0,0 +1,297 @@
+import "dotenv/config";
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { parseArgs } from "node:util";
+import { fileURLToPath } from "node:url";
+import { getUserName as getAlphaUserName, isLoggedIn as isAlphaLoggedIn, login as loginAlpha, logout as logoutAlpha, } from "@companion-ai/alpha-hub/lib";
+import { AuthStorage, DefaultPackageManager, ModelRegistry, SettingsManager } from "@mariozechner/pi-coding-agent";
+import { syncBundledAssets } from "./bootstrap/sync.js";
+import { ensureFeynmanHome, getDefaultSessionDir, getFeynmanAgentDir, getFeynmanHome } from "./config/paths.js";
+import { launchPiChat } from "./pi/launch.js";
+import { normalizeFeynmanSettings, normalizeThinkingLevel, parseModelSpec } from "./pi/settings.js";
+import { loginModelProvider, logoutModelProvider, printModelList, setDefaultModelSpec, } from "./model/commands.js";
+import { printSearchStatus } from "./search/commands.js";
+import { runDoctor, runStatus } from "./setup/doctor.js";
+import { setupPreviewDependencies } from "./setup/preview.js";
+import { runSetup } from "./setup/setup.js";
+import { printInfo, printPanel, printSection } from "./ui/terminal.js";
+import { cliCommandSections, formatCliWorkflowUsage, legacyFlags, readPromptSpecs, topLevelCommandNames, } from "../metadata/commands.mjs";
+const TOP_LEVEL_COMMANDS = new Set(topLevelCommandNames);
+function printHelpLine(usage, description) {
+    const width = 30;
+    const padding = Math.max(1, width - usage.length);
+    printInfo(`${usage}${" ".repeat(padding)}${description}`);
+}
+function printHelp(appRoot) {
+    const workflowCommands = readPromptSpecs(appRoot).filter((command) => command.section === "Research Workflows" && command.topLevelCli);
+    printPanel("Feynman", [
+        "Research-first agent shell built on Pi.",
+        "Use `feynman setup` first if this is a new machine.",
+    ]);
+    printSection("Getting Started");
+    printInfo("feynman");
+    printInfo("feynman setup");
+    printInfo("feynman doctor");
+    printInfo("feynman model");
+    printInfo("feynman search status");
+    printSection("Commands");
+    for (const section of cliCommandSections) {
+        for (const command of section.commands) {
+            printHelpLine(command.usage, command.description);
+        }
+    }
+    printSection("Research Workflows");
+    for (const command of workflowCommands) {
+        printHelpLine(formatCliWorkflowUsage(command), command.description);
+    }
+    printSection("Legacy Flags");
+    for (const flag of legacyFlags) {
+        printHelpLine(flag.usage, flag.description);
+    }
+    printSection("REPL");
+    printInfo("Inside the REPL, slash workflows come from the live prompt-template and extension command set.");
+}
+async function handleAlphaCommand(action) {
+    if (action === "login") {
+        const result = await loginAlpha();
+        const name = result.userInfo &&
+            typeof result.userInfo === "object" &&
+            "name" in result.userInfo &&
+            typeof result.userInfo.name === "string"
+            ? result.userInfo.name
+            : getAlphaUserName();
+        console.log(name ? `alphaXiv login complete: ${name}` : "alphaXiv login complete");
+        return;
+    }
+    if (action === "logout") {
+        logoutAlpha();
+        console.log("alphaXiv auth cleared");
+        return;
+    }
+    if (!action || action === "status") {
+        if (isAlphaLoggedIn()) {
+            const name = getAlphaUserName();
+            console.log(name ? `alphaXiv logged in as ${name}` : "alphaXiv logged in");
+        }
+        else {
+            console.log("alphaXiv not logged in");
+        }
+        return;
+    }
+    throw new Error(`Unknown alpha command: ${action}`);
+}
+async function handleModelCommand(subcommand, args, feynmanSettingsPath, feynmanAuthPath) {
+    if (!subcommand || subcommand === "list") {
+        printModelList(feynmanSettingsPath, feynmanAuthPath);
+        return;
+    }
+    if (subcommand === "login") {
+        await loginModelProvider(feynmanAuthPath, args[0]);
+        return;
+    }
+    if (subcommand === "logout") {
+        await logoutModelProvider(feynmanAuthPath, args[0]);
+        return;
+    }
+    if (subcommand === "set") {
+        const spec = args[0];
+        if (!spec) {
+            throw new Error("Usage: feynman model set <provider/model>");
+        }
+        setDefaultModelSpec(feynmanSettingsPath, feynmanAuthPath, spec);
+        return;
+    }
+    throw new Error(`Unknown model command: ${subcommand}`);
+}
+async function handleUpdateCommand(workingDir, feynmanAgentDir, source) {
+    const settingsManager = SettingsManager.create(workingDir, feynmanAgentDir);
+    const packageManager = new DefaultPackageManager({
+        cwd: workingDir,
+        agentDir: feynmanAgentDir,
+        settingsManager,
+    });
+    packageManager.setProgressCallback((event) => {
+        if (event.type === "start") {
+            console.log(`Updating ${event.source}...`);
+        }
+        else if (event.type === "complete") {
+            console.log(`Updated ${event.source}`);
+        }
+        else if (event.type === "error") {
+            console.error(`Failed to update ${event.source}: ${event.message ?? "unknown error"}`);
+        }
+    });
+    await packageManager.update(source);
+    await settingsManager.flush();
+    console.log("All packages up to date.");
+}
+function handleSearchCommand(subcommand) {
+    if (!subcommand || subcommand === "status") {
+        printSearchStatus();
+        return;
+    }
+    throw new Error(`Unknown search command: ${subcommand}`);
+}
+function loadPackageVersion(appRoot) {
+    try {
+        return JSON.parse(readFileSync(resolve(appRoot, "package.json"), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function resolveInitialPrompt(command, rest, oneShotPrompt, workflowCommands) {
+    if (oneShotPrompt) {
+        return oneShotPrompt;
+    }
+    if (!command) {
+        return undefined;
+    }
+    if (command === "chat") {
+        return rest.length > 0 ? rest.join(" ") : undefined;
+    }
+    if (workflowCommands.has(command)) {
+        return [`/${command}`, ...rest].join(" ").trim();
+    }
+    if (!TOP_LEVEL_COMMANDS.has(command)) {
+        return [command, ...rest].join(" ");
+    }
+    return undefined;
+}
+export async function main() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const appRoot = resolve(here, "..");
+    const feynmanVersion = loadPackageVersion(appRoot).version;
+    const bundledSettingsPath = resolve(appRoot, ".feynman", "settings.json");
+    const feynmanHome = getFeynmanHome();
+    const feynmanAgentDir = getFeynmanAgentDir(feynmanHome);
+    ensureFeynmanHome(feynmanHome);
+    syncBundledAssets(appRoot, feynmanAgentDir);
+    const { values, positionals } = parseArgs({
+        args: process.argv.slice(2),
+        allowPositionals: true,
+        options: {
+            cwd: { type: "string" },
+            doctor: { type: "boolean" },
+            help: { type: "boolean" },
+            "alpha-login": { type: "boolean" },
+            "alpha-logout": { type: "boolean" },
+            "alpha-status": { type: "boolean" },
+            model: { type: "string" },
+            "new-session": { type: "boolean" },
+            prompt: { type: "string" },
+            "session-dir": { type: "string" },
+            "setup-preview": { type: "boolean" },
+            thinking: { type: "string" },
+        },
+    });
+    if (values.help) {
+        printHelp(appRoot);
+        return;
+    }
+    const workingDir = resolve(values.cwd ?? process.cwd());
+    const sessionDir = resolve(values["session-dir"] ?? getDefaultSessionDir(feynmanHome));
+    const feynmanSettingsPath = resolve(feynmanAgentDir, "settings.json");
+    const feynmanAuthPath = resolve(feynmanAgentDir, "auth.json");
+    const thinkingLevel = normalizeThinkingLevel(values.thinking ?? process.env.FEYNMAN_THINKING) ?? "medium";
+    normalizeFeynmanSettings(feynmanSettingsPath, bundledSettingsPath, thinkingLevel, feynmanAuthPath);
+    if (values.doctor) {
+        runDoctor({
+            settingsPath: feynmanSettingsPath,
+            authPath: feynmanAuthPath,
+            sessionDir,
+            workingDir,
+            appRoot,
+        });
+        return;
+    }
+    if (values["setup-preview"]) {
+        const result = setupPreviewDependencies();
+        console.log(result.message);
+        return;
+    }
+    if (values["alpha-login"]) {
+        await handleAlphaCommand("login");
+        return;
+    }
+    if (values["alpha-logout"]) {
+        await handleAlphaCommand("logout");
+        return;
+    }
+    if (values["alpha-status"]) {
+        await handleAlphaCommand("status");
+        return;
+    }
+    const [command, ...rest] = positionals;
+    if (command === "help") {
+        printHelp(appRoot);
+        return;
+    }
+    if (command === "setup") {
+        await runSetup({
+            settingsPath: feynmanSettingsPath,
+            bundledSettingsPath,
+            authPath: feynmanAuthPath,
+            workingDir,
+            sessionDir,
+            appRoot,
+            defaultThinkingLevel: thinkingLevel,
+        });
+        return;
+    }
+    if (command === "doctor") {
+        runDoctor({
+            settingsPath: feynmanSettingsPath,
+            authPath: feynmanAuthPath,
+            sessionDir,
+            workingDir,
+            appRoot,
+        });
+        return;
+    }
+    if (command === "status") {
+        runStatus({
+            settingsPath: feynmanSettingsPath,
+            authPath: feynmanAuthPath,
+            sessionDir,
+            workingDir,
+            appRoot,
+        });
+        return;
+    }
+    if (command === "model") {
+        await handleModelCommand(rest[0], rest.slice(1), feynmanSettingsPath, feynmanAuthPath);
+        return;
+    }
+    if (command === "search") {
+        handleSearchCommand(rest[0]);
+        return;
+    }
+    if (command === "update") {
+        await handleUpdateCommand(workingDir, feynmanAgentDir, rest[0]);
+        return;
+    }
+    if (command === "alpha") {
+        await handleAlphaCommand(rest[0]);
+        return;
+    }
+    const explicitModelSpec = values.model ?? process.env.FEYNMAN_MODEL;
+    if (explicitModelSpec) {
+        const modelRegistry = new ModelRegistry(AuthStorage.create(feynmanAuthPath));
+        const explicitModel = parseModelSpec(explicitModelSpec, modelRegistry);
+        if (!explicitModel) {
+            throw new Error(`Unknown model: ${explicitModelSpec}`);
+        }
+    }
+    await launchPiChat({
+        appRoot,
+        workingDir,
+        sessionDir,
+        feynmanAgentDir,
+        feynmanVersion,
+        thinkingLevel,
+        explicitModelSpec,
+        oneShotPrompt: values.prompt,
+        initialPrompt: resolveInitialPrompt(command, rest, values.prompt, new Set(readPromptSpecs(appRoot).filter((s) => s.topLevelCli).map((s) => s.name))),
+    });
+}

package/dist/config/commands.js

@@ -0,0 +1,71 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { FEYNMAN_CONFIG_PATH, loadFeynmanConfig, saveFeynmanConfig } from "./feynman-config.js";
+function coerceConfigValue(raw) {
+    const trimmed = raw.trim();
+    if (trimmed === "true")
+        return true;
+    if (trimmed === "false")
+        return false;
+    if (trimmed === "null")
+        return null;
+    if (trimmed === "")
+        return "";
+    if (/^-?\d+(\.\d+)?$/.test(trimmed))
+        return Number(trimmed);
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return raw;
+    }
+}
+function getNestedValue(record, path) {
+    return path.split(".").reduce((current, segment) => {
+        if (!current || typeof current !== "object") {
+            return undefined;
+        }
+        return current[segment];
+    }, record);
+}
+function setNestedValue(record, path, value) {
+    const segments = path.split(".");
+    let current = record;
+    for (const segment of segments.slice(0, -1)) {
+        const existing = current[segment];
+        if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+            current[segment] = {};
+        }
+        current = current[segment];
+    }
+    current[segments[segments.length - 1]] = value;
+}
+export function printConfig() {
+    console.log(JSON.stringify(loadFeynmanConfig(), null, 2));
+}
+export function printConfigPath() {
+    console.log(FEYNMAN_CONFIG_PATH);
+}
+export function editConfig() {
+    if (!existsSync(FEYNMAN_CONFIG_PATH)) {
+        saveFeynmanConfig(loadFeynmanConfig());
+    }
+    const editor = process.env.VISUAL || process.env.EDITOR || "vi";
+    const result = spawnSync(editor, [FEYNMAN_CONFIG_PATH], {
+        stdio: "inherit",
+    });
+    if (result.status !== 0) {
+        throw new Error(`Failed to open editor: ${editor}`);
+    }
+}
+export function printConfigValue(key) {
+    const config = loadFeynmanConfig();
+    const value = getNestedValue(config, key);
+    console.log(typeof value === "string" ? value : JSON.stringify(value, null, 2));
+}
+export function setConfigValue(key, rawValue) {
+    const config = loadFeynmanConfig();
+    setNestedValue(config, key, coerceConfigValue(rawValue));
+    saveFeynmanConfig(config);
+    console.log(`Updated ${key}`);
+}

package/dist/config/feynman-config.js

@@ -0,0 +1,42 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { getDefaultSessionDir, getFeynmanConfigPath } from "./paths.js";
+export const FEYNMAN_CONFIG_PATH = getFeynmanConfigPath();
+function readJsonFile(path) {
+    if (!existsSync(path)) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function loadFeynmanConfig(configPath = FEYNMAN_CONFIG_PATH) {
+    const config = readJsonFile(configPath);
+    if (config && typeof config === "object") {
+        return {
+            version: 1,
+            sessionDir: typeof config.sessionDir === "string" && config.sessionDir.trim() ? config.sessionDir : undefined,
+            preview: config.preview && typeof config.preview === "object" ? { ...config.preview } : undefined,
+        };
+    }
+    return {
+        version: 1,
+        sessionDir: getDefaultSessionDir(),
+    };
+}
+export function saveFeynmanConfig(config, configPath = FEYNMAN_CONFIG_PATH) {
+    mkdirSync(dirname(configPath), { recursive: true });
+    writeFileSync(configPath, JSON.stringify({
+        version: 1,
+        ...(config.sessionDir ? { sessionDir: config.sessionDir } : {}),
+        ...(config.preview ? { preview: config.preview } : {}),
+    }, null, 2) + "\n", "utf8");
+}
+export function getConfiguredSessionDir(config = loadFeynmanConfig()) {
+    return typeof config.sessionDir === "string" && config.sessionDir.trim()
+        ? config.sessionDir
+        : getDefaultSessionDir();
+}

package/dist/config/paths.js

@@ -0,0 +1,32 @@
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+export function getFeynmanHome() {
+    return resolve(process.env.FEYNMAN_HOME ?? homedir(), ".feynman");
+}
+export function getFeynmanAgentDir(home = getFeynmanHome()) {
+    return resolve(home, "agent");
+}
+export function getFeynmanMemoryDir(home = getFeynmanHome()) {
+    return resolve(home, "memory");
+}
+export function getFeynmanStateDir(home = getFeynmanHome()) {
+    return resolve(home, ".state");
+}
+export function getDefaultSessionDir(home = getFeynmanHome()) {
+    return resolve(home, "sessions");
+}
+export function getBootstrapStatePath(home = getFeynmanHome()) {
+    return resolve(getFeynmanStateDir(home), "bootstrap.json");
+}
+export function ensureFeynmanHome(home = getFeynmanHome()) {
+    for (const dir of [
+        home,
+        getFeynmanAgentDir(home),
+        getFeynmanMemoryDir(home),
+        getFeynmanStateDir(home),
+        getDefaultSessionDir(home),
+    ]) {
+        mkdirSync(dir, { recursive: true });
+    }
+}

package/dist/feynman-prompt.js

@@ -0,0 +1,63 @@
+export function buildFeynmanSystemPrompt() {
+    return `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.
+- 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 the alpha-backed research tools 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.
+- 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 the installed Pi research packages for broader web/PDF access, document parsing, citation workflows, background processes, memory, session recall, and delegated subtasks when they reduce friction.
+- Feynman ships project subagents for research work. Prefer the \`researcher\`, \`verifier\`, \`reviewer\`, and \`writer\` 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 \`clarify: false, 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/citation pass.
+- 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.
+- Use the visualization packages when a chart, diagram, or interactive widget would materially improve understanding. Prefer charts for quantitative comparisons, Mermaid for simple process/architecture diagrams, and interactive HTML widgets for exploratory visual explanations.
+- 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.
+- Session recall is package-backed. Use \`session_search\` when the user references prior work, asks what has been done before, or when you suspect relevant past context exists.
+- Feynman is intended to support always-on research work. Use the scheduling package when recurring or deferred work is appropriate instead of telling the user to remember manually.
+- Use \`schedule_prompt\` for recurring scans, delayed follow-ups, reminders, and periodic research jobs.
+- If the user asks you to remind, check later, run something nightly, or keep watching something over time, call \`schedule_prompt\`. Do not just promise to do it later.
+- For long-running local work such as experiments, crawls, or log-following, use the process package instead of blocking the main thread unnecessarily. Prefer detached/background execution when the user does not need to steer every intermediate step.
+- 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.
+- 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.
+- After writing a polished artifact, use \`preview_file\` only when the user wants review or export. Prefer browser preview by default; use PDF only when explicitly requested.
+- 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.
+- 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.
+- Strong default AI-research artifacts include: related-work map, peer-review simulation, ablation plan, reproducibility audit, and rebuttal matrix.
+- 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.
+
+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.
+
+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.`;
+}

package/dist/index.js

@@ -0,0 +1,5 @@
+import { main } from "./cli.js";
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});