feat: agent-in-terminal — drop hardcoded workflows, add bash + MCP

Per user direction, remove all hardcoded agent workflow commands.
The agent now drives tool + skill selection from the chat REPL, the
way Claude Code does. Four deterministic utilities remain (`setup`,
`init`, `status`, `ingest`); everything else happens in `chat`.

Removed
  - `thesis curate`      (was: injects long step-by-step curate prompt)
  - `thesis style`       (was: step-by-step style-learner prompt)
  - `thesis write SECT`  (was: step-by-step drafter prompt)
  - `thesis lint`        (was: wiki-linter / citation-linter prompt)
  - `_run()` helper in cli.py
  - All matching tests in test_commands.py + test_extra_coverage.py
  - `test_cli_prompts_have_explicit_stop_markers` in test_loop_guard.py
    (no more hardcoded prompts to assert STOP against)

Added
  - `src/thesis_agent/tools.py`:
      * `bash` tool — runs commands in the workspace root, captures
        stdout+stderr, 60 s timeout (tunable via
        THESIS_SHELL_TIMEOUT_SEC), 64 KB output cap. Disabled
        globally with THESIS_NO_SHELL=1.
      * `_load_mcp_config` + `load_mcp_tools_sync` — picks up
        `.thesis/mcp.json` or `mcp.json` (or $THESIS_MCP_CONFIG),
        supports both flat and `{servers: {...}}` shapes, uses
        `MultiServerMCPClient` from `langchain-mcp-adapters`.
        Tolerant to bad JSON, missing adapters package, failed
        server connections.
      * `build_runtime_tools()` composes bash + MCP tools into the
        list that `build_agent` hands to `create_deep_agent`.
  - `langchain-mcp-adapters` dependency in pyproject.toml.
  - `thesis` (no subcommand) now opens the chat REPL directly;
    `thesis --help` still lists commands.
  - 31 new tests in test_tools.py covering the bash tool, the MCP
    config loader (all three search paths + both config shapes),
    and `build_runtime_tools` composition.

Updated
  - `agent.build_agent`: passes `tools=build_runtime_tools()` instead
    of `tools=[]`. Agent now has shell + MCP at runtime.
  - `MAIN_SYSTEM_PROMPT` in agent.py: rewritten to describe the
    agent-in-terminal model — here are your tools + skills + memory,
    here are the hard rules (citation, never-write-to-raw/data), now
    figure out what the user wants. Removed the "delegate to these
    three subagents for these three tasks" scaffolding.
  - `AGENTS.md` "Write scopes" section: now describes soft
    conventions (not hard sandbox rules) + a "Tools at runtime"
    section listing filesystem / bash / MCP / memory.
  - `README.md`: command table trimmed to the four utilities + chat;
    explains the available tools + how to attach MCP servers.
  - `tests/test_cli_smoke` + `tests/test_commands`: `--help` expectations
    now assert the small command list and explicitly check that
    curate/style/write/lint are GONE (regression guard).

Tests: 348 passed, 1 skipped (Windows symlink rights). Ruff clean.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: NikitasT2003

AGENTS.md

@@ -268,15 +268,38 @@ Report file + line numbers. Do not auto-edit.
 
 ---
 
-## Write scopes (enforced by the sandbox middleware)
+## Write scopes
 
-- `researcher` subagent: **read-only**.
-- `wiki-curator` subagent: may write under `research/wiki/**` and update
+The filesystem tools are scoped to the workspace root. Within the
+workspace the two hard rules are "never `research/raw/`" (sources are
+immutable — ingest normalises them via `thesis ingest` instead) and
+"never `data/`" (agent's own memory databases).
+
+By convention:
+
+- `researcher` subagent — read-only.
+- `wiki-curator` subagent — writes under `research/wiki/**` and edits
   `research/raw/_index.json`.
-- `drafter` subagent: may write under `thesis/**`.
-- Main agent: may write to `research/wiki/**`, `style/STYLE.md`, `thesis/**`,
-  and `research/raw/_index.json`. **Never** to `research/raw/` (sources are
-  immutable) or `data/` (reserved for memory databases).
+- `drafter` subagent — writes under `thesis/**`.
+- Main agent — writes anywhere in the workspace except the two denied
+  paths above. Typically: `research/wiki/**`, `style/STYLE.md`,
+  `thesis/**`, `research/raw/_index.json`.
+
+## Tools at runtime
+
+- **Filesystem** (`read_file`, `write_file`, `edit_file`, `ls`, `glob`,
+  `grep`) scoped to the workspace root via
+  `FilesystemBackend(virtual_mode=True)`.
+- **Bash** — shell in the workspace, captures stdout/stderr, timed out
+  at 60 s by default (`THESIS_SHELL_TIMEOUT_SEC` to change). Use for
+  `thesis ingest`, git, pandoc, pytest, anything deterministic you'd
+  type at a shell. Disabled globally with `THESIS_NO_SHELL=1`.
+- **MCP tools** — servers listed in `.thesis/mcp.json` (or
+  `$THESIS_MCP_CONFIG`) are connected at boot via
+  `langchain-mcp-adapters`. Supports stdio / SSE / streamable_http.
+- **Memory** — writes to `/memories/**` persist across chat sessions
+  (backed by SQLite). Use for user preferences + long-running context;
+  wiki and thesis content stay under their own trees.
 
 ---
 

README.md

@@ -52,19 +52,51 @@ That's it. Non-technical users can stop reading here.
 
 ## Commands
 
+The interface is deliberately small. Four deterministic utilities and
+one agent REPL. There are no hardcoded agent workflows — the agent picks
+the right skill itself based on what you ask.
+
 | Command | What it does |
 |---|---|
 | `thesis setup` | Interactive first-run wizard (API key, workspace, examples). |
 | `thesis init` | Non-interactive workspace scaffold. |
 | `thesis status` | What's in the workspace (counts, DB sizes, thread id). |
 | `thesis ingest [DIR]` | Normalise PDFs/DOCX/EPUB/MD/URLs → markdown. No LLM. |
-| `thesis style` | Compile `style/STYLE.md` from `style/samples/`. |
-| `thesis curate` | Build wiki pages from `pending` sources. |
-| `thesis write SECTION` | Draft one thesis section. |
-| `thesis lint [FILE]` | Citation + grounding linter over chapters. |
-| `thesis chat [--new]` | Interactive REPL. `/new`, `/quit` control the session. |
-
-Global flags: `--thread <id>`, `--version`.
+| `thesis chat` | Agent REPL with streaming + slash commands. **This is where you do everything else** — "curate the pending sources", "draft section 2.1", "lint the wiki", "show me what sources disagree about X". |
+| `thesis` (no subcommand) | Alias for `thesis chat`. |
+
+Slash commands inside chat: `/help`, `/new`, `/thread [id]`, `/status`,
+`/model`, `/clear`, `/history [N]`, `/quit`. Input accepts `\` line
+continuation and ` ``` ` fenced blocks.
+
+## What the agent has access to
+
+- **Filesystem** scoped to the workspace (read_file / write_file /
+  edit_file / ls / glob / grep).
+- **Bash** — shell commands run in the workspace root, 60 s timeout by
+  default. Disable with `THESIS_NO_SHELL=1`, tune timeout with
+  `THESIS_SHELL_TIMEOUT_SEC`.
+- **Skills** from `skills/` (ingest-sources, wiki-curator, wiki-linter,
+  thesis-writer, style-learner, citation-linter). The agent triggers
+  the right one based on what you ask.
+- **MCP servers** — any servers listed in `.thesis/mcp.json` (or
+  pointed at via `$THESIS_MCP_CONFIG`) are connected at start. Example:
+
+  ```json
+  {
+    "servers": {
+      "firecrawl": {
+        "command": "npx",
+        "args": ["-y", "firecrawl-mcp"],
+        "transport": "stdio",
+        "env": {"FIRECRAWL_API_KEY": "fc-..."}
+      }
+    }
+  }
+  ```
+- **Memory** — a SQLite-backed long-term store at `data/store.db`
+  routed through the `/memories/` virtual path. Writes persist across
+  chat sessions.
 
 ## How it works
 

pyproject.toml

@@ -14,6 +14,7 @@ dependencies = [
     "langchain-openai>=0.3.0",
     "langgraph>=0.3.0",
     "langgraph-checkpoint-sqlite>=2.0.0",
+    "langchain-mcp-adapters>=0.1.0",
     "typer>=0.12.0",
     "rich>=13.7.0",
     "questionary>=2.0.1",

src/thesis_agent/agent.py

@@ -16,47 +16,55 @@
 from thesis_agent.memory import memory_context
 from thesis_agent.subagents import get_subagents
 
-MAIN_SYSTEM_PROMPT = """You are the thesis-agent main orchestrator.
-
-The schema in AGENTS.md is your operating manual; follow it exactly. The
-project uses the Karpathy LLM Wiki pattern — a persistent, compounding
-knowledge base under `research/wiki/`. Key reminders:
-
-  * No facts from pretraining. Every factual claim carries `[src:<file>]`
-    tracing to `research/raw/` + the wiki.
-  * The wiki is the index. Start with `research/wiki/index.md`, drill into
-    concept → entity → source pages. `log.md` is the chronological record.
-    Navigate with read_file / glob / grep. No vector search. No web. No shell.
-  * Wiki structure:
-      - `research/wiki/sources/` — one page per raw file
-      - `research/wiki/entities/` — one page per entity (person, method,
-        dataset, concept); accretes across sources
-      - `research/wiki/concepts/` — higher-level themes tying entities
-      - `research/wiki/queries/` — filed-back substantive Q&A
-      - `research/wiki/index.md` — content catalog
-      - `research/wiki/log.md` — chronological, append-only, grep-friendly
-  * Delegate to subagents: wiki-curator to ingest / build wiki pages,
-    drafter to write thesis chapters, researcher for read-only questions.
-  * When a chat question required non-trivial synthesis, FILE THE ANSWER
-    BACK as a query page so reasoning compounds instead of vanishing into
-    chat history. Update `index.md` + `log.md`.
-  * Write scopes are enforced by the sandbox. Do not try to write outside
-    them.
-  * When a claim has no grounding in the wiki/raw, say so. Don't fill from
-    pretraining.
-
-COST + EFFICIENCY RULES (non-negotiable):
-  * Plan briefly, then act. One `ls` or one `glob` is usually enough.
-  * Read each file AT MOST ONCE per task. AGENTS.md is already in your
-    system prompt — never `read_file("AGENTS.md")`.
-  * Do not re-read files you already read this turn.
+MAIN_SYSTEM_PROMPT = """You are thesis-agent, a terminal-native assistant for
+writing a thesis from indexed source material.
+
+The user drives. They'll ask for things like "ingest my new papers",
+"curate the pending sources", "draft section 2.1", "lint the wiki", or
+open-ended questions. Figure out what to do. The skills in `skills/`
+describe conventions for each kind of task; read a skill's body only
+when you need it (descriptions load by default). `AGENTS.md` in this
+message is the schema — the wiki structure, citation format, and hard
+rules — follow it exactly.
+
+What you have:
+
+  * **Filesystem tools** (read_file, write_file, edit_file, ls, glob,
+    grep) scoped to the workspace. Virtual paths like
+    `/research/wiki/index.md` map onto disk under the workspace root.
+  * **Bash tool** — runs shell commands in the workspace. Use for
+    `thesis ingest`, git, pandoc, pytest, anything you'd run at a
+    prompt. The CLI already has a timeout; don't worry about hangs.
+    May be disabled via `THESIS_NO_SHELL=1` — if it is, tell the user.
+  * **Any MCP tools** the user attached via `.thesis/mcp.json`
+    (web search, Obsidian, GitHub, etc.). Check your tool list at the
+    start of a non-trivial task so you know what's available.
+  * **Persistent memory** via the deepagents /memories/ path — writes
+    there survive across chat sessions. Use it for user preferences,
+    long-running goals, and durable context.
+  * **Subagents** (task tool): `wiki-curator` for ingesting sources,
+    `drafter` for writing thesis chapters, `researcher` for read-only
+    research with citations.
+
+Hard rules (from AGENTS.md):
+
+  * Every factual claim in `research/wiki/**` and `thesis/**` carries
+    `[src:<raw_filename>]`. No pretraining facts.
+  * Never write to `research/raw/` — sources are immutable. Never write
+    to `data/` — that's the agent's own memory.
+  * `write_file` refuses to overwrite; use `edit_file` for in-place
+    updates. Never retry a refused write — switch strategies.
+  * When nothing in the wiki/raw grounds a claim, say so and stop.
+
+Efficiency:
+
+  * Plan briefly, then act. One `ls` or one `glob` is usually enough
+    to orient yourself.
+  * Read each file at most once per task. AGENTS.md is already here
+    — never `read_file("AGENTS.md")`.
   * Prefer one decisive tool call over three speculative ones.
-  * When delegating, give the subagent ALL context up front — don't fan
-    out into multiple task() calls for one job.
-  * `write_file` refuses to overwrite existing files — use `edit_file` for
-    in-place updates (manifests, index.md, log.md, page extensions).
-  * If a tool errors, read the error and adjust. Do not retry blindly.
-  * Stop as soon as the user's request is satisfied. No unprompted polish.
+  * Stop as soon as the user's request is satisfied. No unprompted
+    polish, no re-verification loops.
 """
 
 # LangGraph safety ceiling — stops runaway loops before they bill a fortune.
@@ -156,6 +164,8 @@ def build_agent(
         except Exception:
             FilesystemBackend = None
 
+    from thesis_agent.tools import build_runtime_tools
+
     with ExitStack() as stack:
         checkpointer, store = stack.enter_context(memory_context(p))
 
@@ -164,7 +174,10 @@ def build_agent(
             # but with the curator's tighter output cap — the orchestrator
             # mostly plans and delegates; it rarely needs a long reply.
             "model": make_model(mconf.drafter, role="curator"),
-            "tools": [],  # sandbox: no shell, no network, no code exec
+            # Runtime tools: bash (unless `THESIS_NO_SHELL=1`) + any MCP
+            # tools the user attached via `.thesis/mcp.json`. Filesystem
+            # tools come from the FilesystemBackend separately.
+            "tools": build_runtime_tools(),
             "system_prompt": system_prompt,
             "subagents": get_subagents(mconf),
             "checkpointer": checkpointer,

src/thesis_agent/cli.py

@@ -873,137 +873,18 @@ def ingest(
 
 
 # ---------------------------------------------------------------------------
-# agent-backed commands
+# chat — the ONLY agent-facing command. No hardcoded workflows.
+#
+# Previously we shipped `thesis curate` / `style` / `write` / `lint` which
+# injected long step-by-step prompts. That was deterministic scaffolding
+# and it fought with what the LLM + skills already know how to do. Now
+# the user opens chat, asks for what they want ("curate the pending
+# sources", "draft section 2.1", "lint the wiki"), and the agent picks
+# the right skill + tools on its own. Skills live in `skills/` and the
+# schema in `AGENTS.md` still define the conventions — the agent just
+# isn't hand-held through them.
 # ---------------------------------------------------------------------------
 
-def _run(prompt: str, thread_id: str) -> None:
-    from thesis_agent.agent import invoke
-
-    try:
-        reply = invoke(prompt, thread_id=thread_id)
-    except Exception as e:
-        console.print(f"[red]agent error:[/] {e}")
-        raise typer.Exit(1) from e
-    console.print(reply)
-
-
-@app.command()
-def curate(
-    thread: str = typer.Option(None, "--thread", help="Thread ID (defaults to persisted)."),
-) -> None:
-    """Delegate to the wiki-curator to build wiki pages from pending sources."""
-    tid = thread or read_thread_id()
-    write_thread_id(tid)
-    _run(
-        "Curate pending sources per AGENTS.md. Steps, in order, each "
-        "done at most once:\n"
-        "1. Read `research/raw/_index.json` to find entries with "
-        "status 'pending'. If none, reply 'nothing to curate' and STOP.\n"
-        "2. For each pending source, read the raw markdown ONCE.\n"
-        "3. For each source, write exactly one file per path:\n"
-        "   - `research/wiki/sources/<filename>.md` (source summary)\n"
-        "   - `research/wiki/entities/<slug>.md` for each distinct entity\n"
-        "   - `research/wiki/concepts/<slug>.md` for each distinct concept\n"
-        "   Use `write_file` for new paths, `edit_file` for paths that "
-        "already exist. Never retry a refused `write_file`; switch to "
-        "`edit_file` with a specific `old_string`.\n"
-        "4. Use `edit_file` once on `research/wiki/index.md` to add new "
-        "entries.\n"
-        "5. Use `edit_file` once on `research/wiki/log.md` to append "
-        "`## [YYYY-MM-DD] ingest | <title>`.\n"
-        "6. Use `edit_file` once on `research/raw/_index.json` to change "
-        "'pending' to 'curated' for each processed source.\n"
-        "7. Reply with a one-line summary and STOP. No further tool calls.",
-        tid,
-    )
-
-
-@app.command()
-def style(
-    thread: str = typer.Option(None, "--thread"),
-) -> None:
-    """Compile style/STYLE.md from samples in style/samples/."""
-    tid = thread or read_thread_id()
-    write_thread_id(tid)
-    _run(
-        "Compile a style guide. Steps, each done at most once:\n"
-        "1. `ls` `/style/samples/` to list files.\n"
-        "2. `read_file` each sample (each file at most once).\n"
-        "3. Write `/style/STYLE.md` with `write_file` if it does not "
-        "exist, or `edit_file` if it does. Produce a prescriptive style "
-        "guide per the `style-learner` skill (voice, sentence rhythm, "
-        "lexicon, POV, citation placement, structure).\n"
-        "4. Reply with a one-line summary of what you wrote and STOP. "
-        "Do not re-read files. Do not make further tool calls after the "
-        "write.",
-        tid,
-    )
-
-
-@app.command()
-def write(
-    section: str = typer.Argument(..., help="Section identifier from thesis/outline.md, e.g. '2.1'."),
-    thread: str = typer.Option(None, "--thread"),
-) -> None:
-    """Draft one thesis section, grounded in the wiki, in your style."""
-    tid = thread or read_thread_id()
-    write_thread_id(tid)
-    _run(
-        f"Invoke the thesis-writer skill to draft section '{section}' from "
-        f"`thesis/outline.md`. Follow `style/STYLE.md` and cite every factual "
-        f"claim with `[src:<raw_filename>]`. Write to `thesis/chapters/`.",
-        tid,
-    )
-
-
-@app.command()
-def lint(
-    file: Path | None = typer.Argument(
-        None,
-        help="Chapter file to lint. If omitted, runs the wiki-linter over research/wiki/.",
-    ),
-    citations: bool = typer.Option(
-        False, "--citations",
-        help="Force citation-only linting (ungrounded claims, dead [src:...] markers) even with no file argument.",
-    ),
-    thread: str = typer.Option(None, "--thread"),
-) -> None:
-    """Lint the wiki (default) or a thesis chapter.
-
-    Without arguments → wiki health check (orphans, stale claims, missing
-    cross-refs, data gaps, follow-up questions) via the `wiki-linter` skill.
-
-    With a chapter file or `--citations` → citation-only scan via the
-    `citation-linter` skill (dead markers, ungrounded paragraphs).
-    """
-    tid = thread or read_thread_id()
-    write_thread_id(tid)
-
-    if file is not None:
-        _run(
-            f"Invoke the citation-linter skill on {file}. Report dead "
-            f"citations and ungrounded paragraphs. Do not auto-edit.",
-            tid,
-        )
-        return
-
-    if citations:
-        _run(
-            "Invoke the citation-linter skill on `thesis/chapters/*.md`. "
-            "Report dead citations and ungrounded paragraphs. Do not auto-edit.",
-            tid,
-        )
-        return
-
-    _run(
-        "Invoke the wiki-linter skill. Scan `research/wiki/**` for "
-        "contradictions, stale claims, orphan pages, missing cross-refs, "
-        "missing entity/concept pages, and data gaps. Suggest 2-5 "
-        "follow-up questions. Append a lint entry to `research/wiki/log.md`. "
-        "Do not auto-fix.",
-        tid,
-    )
-
 
 _CHAT_BANNER = """[bold]thesis-agent chat[/bold]
 
@@ -1294,7 +1175,10 @@ def _root(
         console.print(f"thesis-agent {__version__}")
         raise typer.Exit(0)
     if ctx.invoked_subcommand is None:
-        console.print(ctx.get_help())
+        # Bare `thesis` drops straight into the agent chat — this is the
+        # primary interface. Use `thesis --help` for the command list,
+        # `thesis ingest` / `setup` / `init` / `status` for utilities.
+        ctx.invoke(chat)
         raise typer.Exit(0)