@saibolla/ada 0.1.2

package/metadata/commands.mjs

@@ -0,0 +1,133 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+
+function parseFrontmatter(text) {
+	const match = text.match(/^---\n([\s\S]*?)\n---\n?/);
+	if (!match) return {};
+
+	const frontmatter = {};
+	for (const line of match[1].split("\n")) {
+		const separator = line.indexOf(":");
+		if (separator === -1) continue;
+		const key = line.slice(0, separator).trim();
+		const value = line.slice(separator + 1).trim();
+		if (!key) continue;
+		frontmatter[key] = value;
+	}
+	return frontmatter;
+}
+
+export function readPromptSpecs(appRoot) {
+	const dir = resolve(appRoot, "prompts");
+	return readdirSync(dir)
+		.filter((f) => f.endsWith(".md"))
+		.map((f) => {
+			const text = readFileSync(resolve(dir, f), "utf8");
+			const fm = parseFrontmatter(text);
+			return {
+				name: f.replace(/\.md$/, ""),
+				description: fm.description ?? "",
+				args: fm.args ?? "",
+				section: fm.section ?? "Research Workflows",
+				topLevelCli: fm.topLevelCli === "true",
+			};
+		});
+}
+
+export const extensionCommandSpecs = [
+	{ name: "help", args: "", section: "Project & Session", description: "Show grouped Ada commands and prefill the editor with a selected command.", publicDocs: true },
+	{ name: "init", args: "", section: "Project & Session", description: "Bootstrap AGENTS.md and session-log folders for a research project.", publicDocs: true },
+	{ name: "outputs", args: "", section: "Project & Session", description: "Browse all research artifacts (papers, outputs, experiments, notes).", publicDocs: true },
+];
+
+export const livePackageCommandGroups = [
+	{
+		title: "Agents & Delegation",
+		commands: [
+			{ name: "agents", usage: "/agents" },
+			{ name: "run", usage: "/run <agent> <task>" },
+			{ name: "chain", usage: "/chain agent1 -> agent2" },
+			{ name: "parallel", usage: "/parallel agent1 -> agent2" },
+		],
+	},
+	{
+		title: "Bundled Package Commands",
+		commands: [
+			{ name: "ps", usage: "/ps" },
+			{ name: "schedule-prompt", usage: "/schedule-prompt" },
+			{ name: "search", usage: "/search" },
+			{ name: "preview", usage: "/preview" },
+			{ name: "new", usage: "/new" },
+			{ name: "quit", usage: "/quit" },
+			{ name: "exit", usage: "/exit" },
+		],
+	},
+];
+
+export const cliCommandSections = [
+	{
+		title: "Core",
+		commands: [
+			{ usage: "ada", description: "Launch the interactive REPL." },
+			{ usage: "ada chat [prompt]", description: "Start chat explicitly, optionally with an initial prompt." },
+			{ usage: "ada help", description: "Show CLI help." },
+			{ usage: "ada setup", description: "Run the guided setup wizard." },
+			{ usage: "ada doctor", description: "Diagnose config, auth, Pi runtime, and preview dependencies." },
+			{ usage: "ada status", description: "Show the current setup summary." },
+		],
+	},
+	{
+		title: "Model Management",
+		commands: [
+			{ usage: "ada model list", description: "List available models in Pi auth storage." },
+			{ usage: "ada model login [id]", description: "Login to a Pi OAuth model provider." },
+			{ usage: "ada model logout [id]", description: "Logout from a Pi OAuth model provider." },
+			{ usage: "ada model set <provider/model>", description: "Set the default model." },
+		],
+	},
+	{
+		title: "AlphaXiv",
+		commands: [
+			{ usage: "ada alpha login", description: "Sign in to alphaXiv." },
+			{ usage: "ada alpha logout", description: "Clear alphaXiv auth." },
+			{ usage: "ada alpha status", description: "Check alphaXiv auth status." },
+		],
+	},
+	{
+		title: "Utilities",
+		commands: [
+			{ usage: "ada packages list", description: "Show core and optional Pi package presets." },
+			{ usage: "ada packages install <preset>", description: "Install optional package presets on demand." },
+			{ usage: "ada search status", description: "Show Pi web-access status and config path." },
+			{ usage: "ada update [package]", description: "Update installed packages, or a specific package." },
+		],
+	},
+];
+
+export const legacyFlags = [
+	{ usage: '--prompt "<text>"', description: "Run one prompt and exit." },
+	{ usage: "--alpha-login", description: "Sign in to alphaXiv and exit." },
+	{ usage: "--alpha-logout", description: "Clear alphaXiv auth and exit." },
+	{ usage: "--alpha-status", description: "Show alphaXiv auth status and exit." },
+	{ usage: "--model <provider:model>", description: "Force a specific model." },
+	{ usage: "--thinking <level>", description: "Set thinking level: off | minimal | low | medium | high | xhigh." },
+	{ usage: "--cwd <path>", description: "Set the working directory for tools." },
+	{ usage: "--session-dir <path>", description: "Set the session storage directory." },
+	{ usage: "--new-session", description: "Start a new persisted session." },
+	{ usage: "--doctor", description: "Alias for `ada doctor`." },
+	{ usage: "--setup-preview", description: "Alias for `ada setup preview`." },
+];
+
+export const topLevelCommandNames = ["alpha", "chat", "doctor", "help", "model", "packages", "search", "setup", "status", "update", "web"];
+
+export function formatSlashUsage(command) {
+	return `/${command.name}${command.args ? ` ${command.args}` : ""}`;
+}
+
+export function formatCliWorkflowUsage(command) {
+	return `ada ${command.name}${command.args ? ` ${command.args}` : ""}`;
+}
+
+export function getExtensionCommandSpec(name) {
+	return extensionCommandSpecs.find((command) => command.name === name);
+}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@saibolla/ada",
+  "version": "0.1.2",
+  "description": "The AI research agent for the terminal",
+  "license": "Apache-2.0",
+  "type": "module",
+  "engines": {
+    "node": ">=20.18.1"
+  },
+  "bin": {
+    "ada": "bin/ada.js"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "!dist/release/",
+    "metadata/",
+    ".ada/agents/",
+    ".ada/settings.json",
+    ".ada/SYSTEM.md",
+    ".ada/themes/",
+    "extensions/",
+    "prompts/",
+    "logo.mjs",
+    "logo.d.mts",
+    "scripts/",
+    "skills/",
+    "AGENTS.md",
+    "README.md",
+    ".env.example"
+  ],
+  "scripts": {
+    "preinstall": "node ./scripts/check-node-version.mjs",
+    "build": "tsc -p tsconfig.build.json",
+    "build:native-bundle": "node ./scripts/build-native-bundle.mjs",
+    "dev": "tsx src/index.ts",
+    "prepack": "npm run build && node ./scripts/prepare-runtime-workspace.mjs",
+    "start": "tsx src/index.ts",
+    "start:dist": "node ./bin/ada.js",
+    "test": "node --import tsx --test --test-concurrency=1 tests/*.test.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "pi-package",
+    "research-agent",
+    "literature-review",
+    "experiments"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ],
+    "prompts": [
+      "./prompts"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "dependencies": {
+    "@ada/alpha-hub": "file:./packages/alpha-hub",
+    "@mariozechner/pi-ai": "^0.62.0",
+    "@mariozechner/pi-coding-agent": "^0.62.0",
+    "@sinclair/typebox": "^0.34.48",
+    "dotenv": "^17.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/saikrishnabolla/ada.git"
+  },
+  "homepage": "https://github.com/saikrishnabolla/ada#readme",
+  "bugs": {
+    "url": "https://github.com/saikrishnabolla/ada/issues"
+  }
+}

package/prompts/audit.md

@@ -0,0 +1,17 @@
+---
+description: Compare a paper's claims against its public codebase and identify mismatches, omissions, and reproducibility risks.
+args: <item>
+section: Research Workflows
+topLevelCli: true
+---
+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.
+
+Requirements:
+- Before starting, outline the audit plan: which paper, which repo, which claims to check. Write the plan to `outputs/.plans/<slug>.md`. Present the plan to the user and confirm before proceeding.
+- Use the `researcher` subagent for evidence gathering and the `verifier` subagent to verify sources and add inline citations when the audit is non-trivial.
+- Compare claimed methods, defaults, metrics, and data handling against the actual code.
+- Call out missing code, mismatches, ambiguous defaults, and reproduction risks.
+- Save exactly one audit artifact to `outputs/<slug>-audit.md`.
+- End with a `Sources` section containing paper and repository URLs.

package/prompts/autoresearch.md

@@ -0,0 +1,66 @@
+---
+description: Autonomous experiment loop — try ideas, measure results, keep what works, discard what doesn't, repeat.
+args: <idea>
+section: Research Workflows
+topLevelCli: true
+---
+Start an autoresearch optimization loop for: $@
+
+This command uses pi-autoresearch.
+
+## Step 1: Gather
+
+If `autoresearch.md` and `autoresearch.jsonl` already exist, ask the user if they want to resume or start fresh.
+If `CHANGELOG.md` exists, read the most recent relevant entries before resuming.
+
+Otherwise, collect the following from the user before doing anything else:
+- What to optimize (test speed, bundle size, training loss, build time, etc.)
+- The benchmark command to run
+- The metric name, unit, and direction (lower/higher is better)
+- Files in scope for changes
+- Maximum number of iterations (default: 20)
+
+## Step 2: Environment
+
+Ask the user where to run:
+- **Local** — run in the current working directory
+- **New git branch** — create a branch so main stays clean
+- **Virtual environment** — create an isolated venv/conda env first
+- **Docker** — run experiment code inside an isolated Docker container
+- **Modal** — run on Modal's serverless GPU infrastructure. Write Modal-decorated scripts and execute with `modal run`. Best for GPU-heavy benchmarks with no persistent state between iterations. Requires `modal` CLI.
+- **RunPod** — provision a GPU pod via `runpodctl` and run iterations there over SSH. Best for experiments needing persistent state, large datasets, or SSH access between iterations. Requires `runpodctl` CLI.
+
+Do not proceed without a clear answer.
+
+## Step 3: Confirm
+
+Present the full plan to the user before starting:
+
+```
+Optimization target: [metric] ([direction])
+Benchmark command:   [command]
+Files in scope:      [files]
+Environment:         [chosen environment]
+Max iterations:      [N]
+```
+
+Ask the user to confirm. Do not start the loop without explicit approval.
+
+## Step 4: Run
+
+Initialize the session: create `autoresearch.md`, `autoresearch.sh`, run the baseline, and start looping.
+
+Each iteration: edit → commit → `run_experiment` → `log_experiment` → keep or revert → repeat. Do not stop unless interrupted or `maxIterations` is reached.
+After the baseline and after meaningful iteration milestones, append a concise entry to `CHANGELOG.md` summarizing what changed, what metric result was observed, what failed, and the next step.
+
+## Key tools
+
+- `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 result, auto-commit, update dashboard
+
+## Subcommands
+
+- `/autoresearch <text>` — start or resume the loop
+- `/autoresearch off` — stop the loop, keep data
+- `/autoresearch clear` — delete all state and start fresh

package/prompts/compare.md

@@ -0,0 +1,18 @@
+---
+description: Compare multiple sources on a topic and produce a source-grounded matrix of agreements, disagreements, and confidence.
+args: <topic>
+section: Research Workflows
+topLevelCli: true
+---
+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.
+
+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`. Present the plan to the user and confirm before proceeding.
+- 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 with `pi-charts` when the comparison involves quantitative metrics. Use Mermaid for method or architecture comparisons.
+- 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

@@ -0,0 +1,189 @@
+---
+description: Run a thorough, source-heavy investigation on a topic and produce a durable research brief with inline citations.
+args: <topic>
+section: Research Workflows
+topLevelCli: true
+---
+Run a deep research workflow for: $@
+
+You are the Lead Researcher. You plan, delegate, evaluate, verify, write, and cite. Internal orchestration is invisible to the user unless they ask.
+
+## 1. Plan
+
+Analyze the research question using extended thinking. Develop a research strategy:
+- Key questions that must be answered
+- Evidence types needed (papers, web, code, data, docs)
+- Sub-questions disjoint enough to parallelize
+- Source types and time periods that matter
+- Acceptance criteria: what evidence would make the answer "sufficient"
+
+Derive a short slug from the topic (lowercase, hyphens, no filler words, ≤5 words — e.g. "cloud-sandbox-pricing" not "deepresearch-plan"). Write the plan to `outputs/.plans/<slug>.md` as a self-contained artifact. Use this same slug for all artifacts in this run.
+If `CHANGELOG.md` exists, read the most recent relevant entries before finalizing the plan. Once the workflow becomes multi-round or spans enough work to merit resume support, append concise entries to `CHANGELOG.md` after meaningful progress and before stopping.
+
+```markdown
+# Research Plan: [topic]
+
+## Questions
+1. ...
+
+## Strategy
+- Researcher allocations and dimensions
+- Expected rounds
+
+## Acceptance Criteria
+- [ ] All key questions answered with ≥2 independent sources
+- [ ] Contradictions identified and addressed
+- [ ] No single-source claims on critical findings
+
+## Task Ledger
+| ID | Owner | Task | Status | Output |
+|---|---|---|---|---|
+| T1 | lead / researcher | ... | todo | ... |
+
+## Verification Log
+| Item | Method | Status | Evidence |
+|---|---|---|---|
+| Critical claim / computation / figure | source cross-read / rerun / direct fetch / code check | pending | path or URL |
+
+## Decision Log
+(Updated as the workflow progresses)
+```
+
+Also persist the plan to memory so it survives context truncation.
+
+Present the plan to the user and ask them to confirm before proceeding. If the user wants changes, revise the plan first.
+
+## 2. Scale decision
+
+| Query type | Execution |
+|---|---|
+| Single fact or narrow question | Search directly yourself, no subagents, 3-10 tool calls |
+| Direct comparison (2-3 items) | 2 parallel `researcher` subagents |
+| Broad survey or multi-faceted topic | 3-4 parallel `researcher` subagents |
+| Complex multi-domain research | 4-6 parallel `researcher` subagents |
+
+Never spawn subagents for work you can do in 5 tool calls.
+
+## 3. Spawn researchers
+
+Launch parallel `researcher` subagents via `subagent`. Each gets a structured brief with:
+- **Objective:** what to find
+- **Output format:** numbered sources, evidence table, inline source references
+- **Tool guidance:** which search tools to prioritize
+- **Task boundaries:** what NOT to cover (another researcher handles that)
+- **Task IDs:** the specific ledger rows they own and must report back on
+
+Assign each researcher a clearly disjoint dimension — different source types, geographic scopes, time periods, or technical angles. Never duplicate coverage.
+
+```
+{
+  tasks: [
+    { agent: "researcher", task: "...", output: "<slug>-research-web.md" },
+    { agent: "researcher", task: "...", output: "<slug>-research-papers.md" }
+  ],
+  concurrency: 4,
+  failFast: false
+}
+```
+
+Researchers write full outputs to files and pass references back — do not have them return full content into your context.
+Researchers must not silently merge or skip assigned tasks. If something is impossible or redundant, mark the ledger row `blocked` or `superseded` with a note.
+
+## 4. Evaluate and loop
+
+After researchers return, read their output files and critically assess:
+- Which plan questions remain unanswered?
+- Which answers rest on only one source?
+- Are there contradictions needing resolution?
+- Is any key angle missing entirely?
+- Did every assigned ledger task actually get completed, blocked, or explicitly superseded?
+
+If gaps are significant, spawn another targeted batch of researchers. No fixed cap on rounds — iterate until evidence is sufficient or sources are exhausted.
+
+Update the plan artifact (`outputs/.plans/<slug>.md`) task ledger, verification log, and decision log after each round.
+When the work spans multiple rounds, also append a concise chronological entry to `CHANGELOG.md` covering what changed, what was verified, what remains blocked, and the next recommended step.
+
+Most topics need 1-2 rounds. Stop when additional rounds would not materially change conclusions.
+
+## 5. Write the report
+
+Once evidence is sufficient, YOU write the full research brief directly. Do not delegate writing to another agent. Read the research files, synthesize the findings, and produce a complete document:
+
+```markdown
+# Title
+
+## Executive Summary
+2-3 paragraph overview of key findings.
+
+## Section 1: ...
+Detailed findings organized by theme or question.
+
+## Section N: ...
+
+## Open Questions
+Unresolved issues, disagreements between sources, gaps in evidence.
+```
+
+When the research includes quantitative data (benchmarks, performance comparisons, trends), generate charts using `pi-charts`. Use Mermaid diagrams for architectures and processes. Every visual must have a caption and reference the underlying data.
+
+Before finalizing the draft, do a claim sweep:
+- map each critical claim, number, and figure to its supporting source or artifact in the verification log
+- downgrade or remove anything that cannot be grounded
+- label inferences as inferences
+- if code or calculations were involved, record which checks were actually run and which remain unverified
+
+Save this draft to `outputs/.drafts/<slug>-draft.md`.
+
+## 6. Cite
+
+Spawn the `verifier` agent to post-process YOUR draft. The verifier agent adds inline citations, verifies every source URL, and produces the final output:
+
+```
+{ agent: "verifier", task: "Add inline citations to <slug>-draft.md using the research files as source material. Verify every URL.", output: "<slug>-brief.md" }
+```
+
+The verifier agent does not rewrite the report — it only anchors claims to sources and builds the numbered Sources section.
+
+## 7. Verify
+
+Spawn the `reviewer` agent against the cited draft. The reviewer checks for:
+- Unsupported claims that slipped past citation
+- Logical gaps or contradictions between sections
+- Single-source claims on critical findings
+- Overstated confidence relative to evidence quality
+
+```
+{ agent: "reviewer", task: "Verify <slug>-brief.md — flag any claims that lack sufficient source backing, identify logical gaps, and check that confidence levels match evidence strength. This is a verification pass, not a peer review.", output: "<slug>-verification.md" }
+```
+
+If the reviewer flags FATAL issues, fix them in the brief before delivering. MAJOR issues get noted in the Open Questions section. MINOR issues are accepted.
+After fixes, run at least one more review-style verification pass if any FATAL issues were found. Do not assume one fix solved everything.
+
+## 8. Deliver
+
+Copy the final cited and verified output to the appropriate folder:
+- Paper-style drafts → `papers/`
+- Everything else → `outputs/`
+
+Save the final output as `<slug>.md` (in `outputs/` or `papers/` per the rule above).
+
+Write a provenance record alongside it as `<slug>.provenance.md`:
+
+```markdown
+# Provenance: [topic]
+
+- **Date:** [date]
+- **Rounds:** [number of researcher rounds]
+- **Sources consulted:** [total unique sources across all research files]
+- **Sources accepted:** [sources that survived citation verification]
+- **Sources rejected:** [dead links, unverifiable, or removed]
+- **Verification:** [PASS / PASS WITH NOTES — summary of reviewer findings]
+- **Plan:** outputs/.plans/<slug>.md
+- **Research files:** [list of intermediate <slug>-research-*.md files]
+```
+
+## Background execution
+
+If the user wants unattended execution or the sweep will clearly take a while:
+- Launch the full workflow via `subagent` using `clarify: false, async: true`
+- Report the async ID and how to check status with `subagent_status`

package/prompts/draft.md

@@ -0,0 +1,19 @@
+---
+description: Turn research findings into a polished paper-style draft with equations, sections, and explicit claims.
+args: <topic>
+section: Research Workflows
+topLevelCli: true
+---
+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.
+
+Requirements:
+- Before writing, outline the draft structure: proposed title, sections, key claims to make, source material to draw from, and a verification log for the critical claims, figures, and calculations. Write the outline to `outputs/.plans/<slug>.md`. Present the outline to the user and confirm before proceeding.
+- Use the `writer` subagent when the draft should be produced from already-collected notes, then use the `verifier` subagent to add inline citations and verify sources.
+- 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.
+- Generate charts with `pi-charts` for quantitative data, benchmarks, and comparisons. Use Mermaid for architectures and pipelines. Every figure needs a caption.
+- 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/jobs.md

@@ -0,0 +1,16 @@
+---
+description: Inspect active background research work, including running processes and scheduled follow-ups.
+section: Project & Session
+topLevelCli: true
+---
+Inspect active background work for this project.
+
+Requirements:
+- Use the `process` tool with the `list` action to inspect running and finished managed background processes.
+- Use the scheduling tooling to list active recurring or deferred jobs if any are configured.
+- Summarize:
+  - active background processes
+  - queued or recurring research watches
+  - failures that need attention
+  - the next concrete command the user should run if they want logs or detailed status
+- Be concise and operational.

package/prompts/litreview.md

@@ -0,0 +1,18 @@
+---
+description: Run a literature review on a topic using paper search and primary-source synthesis.
+args: <topic>
+section: Research Workflows
+topLevelCli: true
+---
+Investigate the following topic 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.
+
+## Workflow
+
+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. Write the plan to `outputs/.plans/<slug>.md`. Present the plan to the user and confirm before proceeding.
+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`. Do not silently skip assigned questions; mark them `done`, `blocked`, or `superseded`.
+3. **Synthesize** — Separate consensus, disagreements, and open questions. When useful, propose concrete next experiments or follow-up reading. Generate charts with `pi-charts` for quantitative comparisons across papers and Mermaid diagrams for taxonomies or method pipelines. Before finishing the draft, sweep every strong claim against the verification log and downgrade anything that is inferred or single-source critical.
+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.

package/prompts/log.md

@@ -0,0 +1,14 @@
+---
+description: Write a durable session log with completed work, findings, open questions, and next steps.
+section: Project & Session
+topLevelCli: true
+---
+Write a session log for the current research work.
+
+Requirements:
+- Summarize what was done in this session.
+- Capture the strongest findings or decisions.
+- List open questions, unresolved risks, and concrete next steps.
+- Reference any important artifacts written to `notes/`, `outputs/`, `experiments/`, or `papers/`.
+- If any external claims matter, include direct source URLs.
+- Save the log to `notes/` as markdown with a date-oriented filename.

package/prompts/replicate.md

@@ -0,0 +1,24 @@
+---
+description: Plan or execute a replication workflow for a paper, claim, or benchmark.
+args: <paper>
+section: Research Workflows
+topLevelCli: true
+---
+Design a replication plan for: $@
+
+## Workflow
+
+1. **Extract** — Use the `researcher` subagent to pull implementation details from the target paper and any linked code. If `CHANGELOG.md` exists, read the most recent relevant entries before planning or resuming.
+2. **Plan** — Determine what code, datasets, metrics, and environment are needed. Be explicit about what is verified, what is inferred, what is still missing, and which checks or test oracles will be used to decide whether the replication succeeded.
+3. **Environment** — Before running anything, ask the user where to execute:
+   - **Local** — run in the current working directory
+   - **Virtual environment** — create an isolated venv/conda env first
+   - **Docker** — run experiment code inside an isolated Docker container
+   - **Modal** — run on Modal's serverless GPU infrastructure. Write a Modal-decorated Python script and execute with `modal run <script.py>`. Best for burst GPU jobs that don't need persistent state. Requires `modal` CLI (`pip install modal && modal setup`).
+   - **RunPod** — provision a GPU pod on RunPod and SSH in for execution. Use `runpodctl` to create pods, transfer files, and manage lifecycle. Best for long-running experiments or when you need SSH access and persistent storage. Requires `runpodctl` CLI and `RUNPOD_API_KEY`.
+   - **Plan only** — produce the replication plan without executing
+4. **Execute** — If the user chose an execution environment, implement and run the replication steps there. Save notes, scripts, raw outputs, and results to disk in a reproducible layout. Do not call the outcome replicated unless the planned checks actually passed.
+5. **Log** — For multi-step or resumable replication work, append concise entries to `CHANGELOG.md` after meaningful progress, failed attempts, major verification outcomes, and before stopping. Record the active objective, what changed, what was checked, and the next step.
+6. **Report** — End with a `Sources` section containing paper and repository URLs.
+
+Do not install packages, run training, or execute experiments without confirming the execution environment first.

package/prompts/review.md

@@ -0,0 +1,18 @@
+---
+description: Simulate an AI research peer review with likely objections, severity, and a concrete revision plan.
+args: <artifact>
+section: Research Workflows
+topLevelCli: true
+---
+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.
+
+Requirements:
+- Before starting, outline what will be reviewed, the review criteria (novelty, empirical rigor, baselines, reproducibility, etc.), and any verification-specific checks needed for claims, figures, and reported metrics. Present the plan to the user and confirm before proceeding.
+- Spawn a `researcher` subagent to gather evidence on the artifact — inspect the paper, code, cited work, and any linked experimental artifacts. Save to `<slug>-research.md`.
+- Spawn a `reviewer` subagent with `<slug>-research.md` to produce the final peer review with inline annotations.
+- For small or simple artifacts where evidence gathering is overkill, run the `reviewer` subagent directly instead.
+- If the first review finds FATAL issues and you fix them, run one more verification-style review pass before delivering.
+- Save exactly one review artifact to `outputs/<slug>-review.md`.
+- End with a `Sources` section containing direct URLs for every inspected external source.

package/prompts/watch.md

@@ -0,0 +1,16 @@
+---
+description: Set up a recurring or deferred research watch on a topic, company, paper area, or product surface.
+args: <topic>
+section: Research Workflows
+topLevelCli: true
+---
+Create a research watch for: $@
+
+Derive a short slug from the watch topic (lowercase, hyphens, no filler words, ≤5 words). Use this slug for all files in this run.
+
+Requirements:
+- Before starting, outline the watch plan: what to monitor, what signals matter, what counts as a meaningful change, and the check frequency. Write the plan to `outputs/.plans/<slug>.md`. Present the plan to the user and confirm before proceeding.
+- Start with a baseline sweep of the topic.
+- Use `schedule_prompt` to create the recurring or delayed follow-up instead of merely promising to check later.
+- Save exactly one baseline artifact to `outputs/<slug>-baseline.md`.
+- End with a `Sources` section containing direct URLs for every source used.