@autorag/librarian 2.10.5 → 2.11.0

package/NOTICE

@@ -24,12 +24,12 @@ License: MIT
 @modelcontextprotocol/server@2.3.1
 License: Apache-2.0
 
-@openrouter/sdk@1.4.25
-License: Apache-2.0
-
 chardet@2.2.0
 License: MIT
 
+discord.js@14.27.0
+License: Apache-2.0
+
 fast-xml-parser@5.11.2
 License: MIT
 
@@ -51,6 +51,9 @@ License: MIT
 pdfjs-dist@6.4.299
 License: Apache-2.0
 
+pi-discord-remote@0.2.4
+License: MIT
+
 puppeteer-core@25.13.0
 License: Apache-2.0
 
@@ -66,12 +69,6 @@ License: Apache-2.0
 typebox@1.3.37
 License: MIT
 
-Embedding runtime and model notices:
-licenses/llama.cpp-MIT.txt
-licenses/qwen3-embedding-notice.txt
-licenses/apache-2.0.txt
-licenses/embedding-assets.json
-
 Bundled Windows binaries (vendor/everything, extracted only on Windows):
 Everything 1.4.1.1032 portable (voidtools, David Carpenter)
 License: MIT (closed source); includes PCRE (BSD-3-Clause)
@@ -80,3 +77,11 @@ licenses/everything-MIT-and-PCRE-BSD.txt
 ES 1.1.0.38 command-line interface (voidtools)
 License: MIT
 licenses/es-MIT.txt
+
+Separate programs AutoRAG talks to (not bundled, not distributed, not linked):
+Hister (https://github.com/asciimoo/hister, asciimoo and Hister contributors)
+License: AGPL-3.0-or-later
+AutoRAG ships no Hister code. Users install the unmodified Hister release themselves and AutoRAG only sends
+search requests to its public HTTP API (GET /search, GET /api/config), as a separate program over a network
+socket. AutoRAG does not modify Hister and never hides that Hister is the backend of the `hister` datasource.
+licenses/hister-AGPL-3.0-notice.txt

package/README.md

@@ -18,7 +18,7 @@
 
 > [!IMPORTANT]
 > **Looking for the original AutoRAG (RAG AutoML / pipeline optimization tool)?**
-> This repository now hosts **AutoRAG 2.0**, a complete reimagining of AutoRAG as a self-evolving librarian agent. The original Python-based AutoRAG — the RAG AutoML tool for automatically finding an optimal RAG pipeline for your data — now lives in the [`legacy/`](legacy/) directory of this repository.
+> This repository now hosts **AutoRAG 2.0**, a complete reimagining of AutoRAG as a personal librarian agent for your office work. The original Python-based AutoRAG — the RAG AutoML tool for automatically finding an optimal RAG pipeline for your data — now lives in the [`legacy/`](legacy/) directory of this repository.
 >
 > **The legacy AutoRAG is NOT abandoned.** It continues to be maintained (bug fixes, dependency updates, and PyPI releases via `pip install AutoRAG`) in maintenance mode. Existing users can keep using it exactly as before — see the [legacy README](legacy/README.md) for its documentation, and file issues in this repository as usual. New feature development is focused on AutoRAG Agent (2.0).
 
@@ -131,9 +131,10 @@ does, and searches them right alongside your files:
 
 ### Private by design
 
-- **Embedded on your machine.** Document understanding runs on the local
-  [`qwen3-embedding-0.6b`](docs/model-cards/qwen3-embedding-0.6b.md) model.
-  File contents are never sent to a remote embedder.
+- **Embedded on your machine.** Semantic indexing runs on MinSync's local
+  Qwen3-Embedding-0.6B engine (1024 dimensions), which MinSync provisions and
+  runs; AutoRAG owns no embedding model. File contents are never sent to a
+  remote embedder unless you explicitly configure a remote `minSync.embedder`.
 - **Keys stay encrypted.** Sign-in tokens and API keys live in the system's
   encrypted store, never in a config file.
 - **Bring your own model.** Use the [hosted Dazzi Models plan](#hosted-dazzi-models-plan),
@@ -153,7 +154,7 @@ The app is one way in. The same librarian runs everywhere else:
 |---|---|---|
 | **Desktop app (Dazzi)** | Browsing and asking in one window | [NomaDamas/AutoRAG-app](https://github.com/NomaDamas/AutoRAG-app) (Fair Source, FSL-1.1-MIT) |
 | **Terminal UI** | Interactive, steerable search sessions | [`autorag tui`](#2-search-from-cli) |
-| **Messenger** | Asking the librarian from a chat app | [Telegram](#messenger-connections) |
+| **Messenger** | Asking the librarian from a chat app | [Telegram, Discord](#messenger-connections) |
 | **CLI** | Scripts, indexing, health checks | [CLI Command Reference](#cli-command-reference) |
 | **MCP server** | Feeding retrieval to Claude Code, Codex, and other agents | [AutoRAG Lite MCP Server](#autorag-lite-mcp-server) |
 | **TypeScript API** | Embedding the librarian in your own app | [Programmatic usage](#3-programmatic-usage-typescript-api) |
@@ -165,7 +166,7 @@ The app is one way in. The same librarian runs everywhere else:
 
 Search tools dump file paths and matching lines — forcing you to open files, read context, and synthesize answers yourself.
 
-**AutoRAG Agent is a self-evolving librarian agent.** Built on the [Pi](https://github.com/earendil-works/pi-mono) agent framework, a single configured model searches across multiple retrieval methods, opens source documents directly via `bash` to verify ground truth, and curates answers into clean, numbered knowledge units:
+**AutoRAG Agent is a personal librarian agent that helps with your office work.** Built on the [Pi](https://github.com/earendil-works/pi-mono) agent framework, a single configured model searches your files, mail, chats, and notes in place, opens source documents directly via `bash` to verify ground truth, and curates answers into clean, numbered knowledge units. Because it works for you rather than only on your index, it can also act on your files when you ask, such as organizing, renaming, moving, or editing them with a record of every change:
 
 ```text
 You ask:  "What changes were made to the cloud infrastructure contract in Q3?"
@@ -186,9 +187,9 @@ AutoRAG Agent:
 
 Three principles drive every design decision in AutoRAG Agent:
 
-1. **Never migrate your data to search it.** Traditional RAG systems force you to upload, ETL, and duplicate your files into a centralized vector database. AutoRAG Agent federates your data **in place**, querying CLI-native stores (`lazykatok`, `discrawl`, `slacrawl`, `mailcrawl`, `rclone`, `qmd`) where your data already lives. Results retain opaque, source-native identities (`/kakao/...`, `/slack/...`) that preserve local access control and privacy. *(See our [Competitive Landscape Study](docs/competitive-landscape-2026-09.md) on why in-place federation is the durable differentiator).*
+1. **Never migrate your data to search it.** Traditional RAG systems force you to upload, ETL, and duplicate your files into a centralized vector database. AutoRAG Agent federates your data **in place**, querying CLI-native stores (`lazykatok`, `discrawl`, `slacrawl`, `mailcrawl`, `rclone`) where your data already lives. Results retain opaque, source-native identities (`/kakao/...`, `/slack/...`) that preserve local access control and privacy. *(See our [Competitive Landscape Study](docs/competitive-landscape-2026-09.md) on why in-place federation is the durable differentiator).*
 
-2. **Just works — no RAG degree required.** No pipeline tuning, no vector-DB maintenance, and no remote embedding keys required. AutoRAG Agent automatically manages [MinSync](docs/minsync-setup.md) for incremental Change Data Capture (CDC) chunking and provides a local [embedding gateway](docs/embedding-runtime.md) out of the box with zero external telemetry. A [remote rerank model](docs/rerank.md) (the hosted Dazzi Models reranker when signed in, else OpenRouter `voyageai/rerank-3-lite`) is an opt-in extra.
+2. **Just works — no RAG degree required.** No pipeline tuning, no vector-DB maintenance, and no remote embedding keys required. AutoRAG Agent automatically manages [MinSync](docs/minsync-setup.md) for incremental Change Data Capture (CDC) chunking and provides a local [embedding backend](docs/minsync-setup.md#embedding-backends) out of the box with zero external telemetry. A [remote rerank model](docs/rerank.md) (the hosted Dazzi Models reranker when signed in, else OpenRouter `voyageai/rerank-3-lite`) is an opt-in extra.
 
 3. **Fast by design.** Rather than coordinating slow multi-agent hierarchies, a single configured model owns the entire retrieval, direct-read, and curation loop. Local CDC chunks (BM25, vector, and hybrid modes) deliver rapid, low-latency turnaround across multi-turn research queries.
 
@@ -201,7 +202,7 @@ AutoRAG Agent orchestrates five integrated subsystems:
 1. **Retrieval Memory (`check_memory`):** After each answer, cited evidence Jev judges to genuinely support it is stored in `~/.autorag/memory.json`. Later searches receive this conversation's evidence, similar past questions, and long-term insights as **advisory reference** — it never reorders results or overrides current evidence. See [docs/retrieval-memory.md](docs/retrieval-memory.md).
 2. **Pluggable Multi-Method Retrieval:**
    - **BM25 Lexical Search:** Fast keyword ranking via MinSync over parsed markdown mirrors. AutoRAG always uses MinSync's `multilingual` tokenizer, which keeps each original word and adds Korean morphemes (via the [Kiwi](https://github.com/bab2min/Kiwi) library), so both `연구목표` and `인증서를` → `인증서` match; without Kiwi AutoRAG warns and tokenizes on whitespace. See [docs/minsync-setup.md](docs/minsync-setup.md#bm25-tokenizer).
-   - **Semantic Vector Search:** Dense vector retrieval over CDC chunks via the built-in embedding gateway.
+   - **Semantic Vector Search:** Dense vector retrieval over CDC chunks via the shared MinSync embedder.
    - **Hybrid Search:** Combines BM25 and vector ranking via Reciprocal Rank Fusion (RRF).
    - **Jikji Find-First Discovery:** Local CLI-backed fast discovery answer packs.
    - **Everything File-Name Search (Windows):** The bundled [voidtools Everything](https://www.voidtools.com/) indexes file and folder names under your search roots so the agent finds files by name, extension, path, size, or date instantly (`everything_search`).
@@ -217,8 +218,12 @@ AutoRAG uses `@earendil-works/pi-coding-agent` as the runtime host for model ses
 
 The CLI TUI (`autorag tui`) is Pi's interactive mode hosted on the AutoRAG librarian: there is no separate AutoRAG renderer. Pi owns the terminal UI and its native in-session commands — `/login`/`/logout`, `/model`, `/resume`, `/new`, `/tree`, `/compact`, and `/settings` — so provider sign-in and model selection work on first launch even when no AutoRAG model is configured. AutoRAG registers its retrieval tools and runs the two-phase search in the same Pi session, where the model's progress notes, first answer, and final answer are ordinary assistant messages, so resume and two-phase search keep working together.
 
+A fresh session — at launch and after `/new` (or `/reload`) — opens on AutoRAG's own welcome screen: the AutoRAG logo, the version, and three rotating tips, centered and scaled down to a smaller logo or a plain wordmark on narrow terminals. Pi's own logo, key-hint list, and loaded skills/prompts/extensions listing are hidden by default (`quietStartup: "header"`). A `quietStartup` saved in Pi's global or project `settings.json` wins: `true` removes the banner, `false` brings Pi's resource listing back.
+
 Typing while a search runs works like steering one of Pi's own turns. **Enter** steers the running search: AutoRAG treats the text as a correction of a search that is going wrong, delivers it before the search's next model request (also between phases, where no turn is streaming), cuts in-flight retrieval short so the correction lands promptly, and always runs the verification phase so the answer reflects the correction. **Alt+Enter** queues a new question that runs after the current search answers. **Esc** stops the search instead of letting it continue into its next phase. Pi's registered `/` commands still run during a search; any other line starting with `/` (a path, for example) is a steer like any other text. A query typed after a search answers is a new search in the same session, as before.
 
+From the moment a question is submitted, a live progress widget sits above the editor: a spinner, the elapsed time, and one line per step the search is running (routing, splitting the question, each retrieval source with its hit count and time, ranking, the first answer, verification). A slow source shows its own running timer, a failing source shows its error text verbatim, and the widget disappears when the answer is final or **Esc** stops the search. While the model streams, Pi's own `Working` loader takes over and the widget keeps only the header and steps.
+
 Update notices are AutoRAG's, not Pi's: `autorag tui` suppresses Pi's "run `pi update`" banner (Pi is a bundled host, not a separate install) and instead checks the published `@autorag/librarian` release, showing a one-line notice in the session when a newer version exists. Set `AUTORAG_NO_UPDATE_CHECK=1` to skip the lookup; `AUTORAG_UPDATE_CHECK_URL` overrides the registry endpoint.
 
 ---
@@ -229,12 +234,15 @@ Update notices are AutoRAG's, not Pi's: `autorag tui` suppresses Pi's "run `pi u
 |---|---|---|
 | **Telegram** | Supported | [`autorag tui --telegram`](docs/telegram.md) |
 | **WhatsApp** | Supported (unofficial client) | [`autorag tui --whatsapp`](docs/whatsapp.md) |
-| Discord, Slack, others | Not supported yet | |
+| **Discord** | Supported (no steering yet) | [`autorag tui --discord`](docs/discord.md) |
+| Slack, others | Not supported yet | |
 
 Telegram runs through the [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) bridge inside a running `autorag tui` session: questions you send the bot get the same routing and two-phase search as the terminal. Setup, commands, and keeping it running are in [docs/telegram.md](docs/telegram.md).
 
 WhatsApp runs through the pinned [`whatsapp-pi`](https://www.npmjs.com/package/whatsapp-pi) extension the same way; see [docs/whatsapp.md](docs/whatsapp.md).
 
+Discord runs through the [`pi-discord-remote`](https://pi.dev/packages/pi-discord-remote) extension and creates one channel per TUI session; the fast answer and the verified final answer are posted as they land. Setup, permissions, and limits are in [docs/discord.md](docs/discord.md).
+
 ## Installation & Setup
 
 AutoRAG Agent is published as `@autorag/librarian` (requires Node.js ≥ 24 or Bun):
@@ -467,13 +475,11 @@ mirrored are kept and not re-parsed on the next run. `onProgress` reports `parse
 | `autorag health` | Check model provider authentication, token validity, and API reachability |
 | `autorag models list` | List chat models the pi runtime can resolve (built-ins, `models.json`, custom/extension providers) with provider auth status; never prints credential values |
 | `autorag update-check` | Compare the running `autorag` against the published npm version (also runs on `autorag tui` launch) |
-| `autorag tui` | Open Pi's interactive librarian TUI (`/login`, `/model`, `/resume`, …); `--telegram` / `--whatsapp` add the Telegram / WhatsApp remote-control bridges |
+| `autorag tui` | Open Pi's interactive librarian TUI (`/login`, `/model`, `/resume`, …); `--telegram` / `--whatsapp` / `--discord` add the Telegram / WhatsApp / Discord remote-control bridges |
 | `autorag duplicates [DIR]` | Read-only scan for exact and near-duplicate document families with `dupey` |
 | `autorag lite ...` | CLI bootstrap, indexing repair, terminal maintenance, and fallback interface; agents use MCP for normal Lite operation |
 | `autorag memory inspect` | Render a read-only, path-opaque snapshot of retrieval memory (judged evidence, curated results, evidence chunks, insights); model-free |
 | `autorag evidence <session>` | Inspect persisted evidence behind numbered results; MCP clients normally use `autorag.evidence`, and the CLI stays available for terminal maintenance |
-| `autorag serve` | Start the P2P query server over SimpleX (opt-in) |
-| `autorag p2p ...` | Manage peer trust, query approvals, and sharing policies |
 
 ---
 
@@ -499,6 +505,36 @@ Core Lite tools include `autorag.status`, `autorag.search`,
 integrated datasources expose additional scoped search tools. Read-only MCP
 mode omits mutating tools such as refresh and report.
 
+## Using external MCP servers and agent skills
+
+AutoRAG is also an MCP *client*. Servers listed in the pi agent directory's `mcp.json`
+(`~/.pi/agent/mcp.json`, or `<piAgentDir>/mcp.json` when the agent is given one) are connected
+when a TUI session or a one-shot `autorag search` starts, and their tools reach the model next to
+AutoRAG's own tools. The file uses the format shared by other MCP clients:
+
+```json
+{
+  "mcpServers": {
+    "filesystem": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "."] },
+    "docs": { "url": "https://example.com/mcp", "headers": { "Authorization": "Bearer ${DOCS_TOKEN}" } }
+  }
+}
+```
+
+- **Exposure.** By default a server's tools are reached through the `codemode` tool (the model
+  writes a short script that calls them); `"exposure": "direct"` declares them to the model
+  like built-in tools, `"deferred"` loads them on demand through `tool_search`, and `"hidden"`
+  turns a server off. `description` is shown to the model so it knows when to use the server.
+- **Only the user-level file is read.** A project `.pi/mcp.json` is ignored on purpose: it would
+  let any folder AutoRAG starts in choose which processes run.
+- **Failures are reported verbatim.** An invalid entry or a server that fails to start is
+  reported at session start with pi's own message; the other servers keep working.
+- **Inside the TUI**, `/mcp` lists servers, reconnects them, signs in to OAuth servers, and
+  changes exposure. Pi's `/skill:<name>` commands and `<available_skills>` list also work for
+  any agent skill installed under the agent directory.
+- MCP results are data from an external server. AutoRAG tells the model never to follow
+  instructions found in them.
+
 ---
 
 ## ⚡ AutoRAG Lite: Model-Free Retrieval Engine
@@ -582,7 +618,8 @@ Do not copy or retain the removed `autorag-lite-search` skill.
    autorag search "your question" --json
    ```
 4. **Safety Guidelines for Agents:**
-   - **Never delete, move, or modify original user documents.**
+   - **Setup, diagnostics, indexing, and refresh never modify your documents.** An agent that installs, configures, or repairs AutoRAG (Claude Code, Codex, and similar) must not move, rename, edit, or delete user documents as part of that work. That rule is about those procedures; it is not a limit on the librarian itself, which may organize, create, or modify files in local sessions when the user asks (see `Local File Organization` in the system prompt).
+   - **Never permanently delete.** Deletion goes to the OS trash, and every change is listed as old path → new path so it can be undone.
    - AutoRAG writes index artifacts into `<workspace>/.autorag/` and Jikji's central store (`<OS data dir>/jikji/`, override with `JIKJI_DATA_DIR`). Jikji also drops a `.jikji_agent_map.md` guide into each indexed root.
    - Never print or leak API keys, tokens, or credential values into stdout or logs.
 
@@ -603,13 +640,14 @@ AutoRAG Agent connects to external tools and communication platforms using dedic
 | **Notion** | `notion` | [`notcrawl`](https://github.com/openclaw/notcrawl) CLI | Local page/database/block archive + FTS5 | Lexical FTS5 |
 | **Email Archives** | `mailcrawl` | [`mailcrawl`](https://github.com/NomaDamas/mailcrawl) CLI | Local Gmail, IMAP, and Maildir storage | BM25, Semantic, Hybrid |
 | **Local Mail Export**| `mail-export` | Built-in `.mbox` / `.eml` parser | Local filesystem mailboxes | Lexical |
-| **Obsidian Vaults** | `obsidian` | [`qmd`](https://github.com/tobi/qmd) CLI | Direct markdown vault indexing | BM25, Semantic |
+| **Obsidian Vaults** | `obsidian` | Indexed with MinSync in its own workspace (no external CLI) | Markdown notes, folder-scopable | Lexical (BM25), Semantic, Scoped |
 | **GitHub** | `github` | GitHub REST API | In-memory fetched Issues and Pull Requests | Lexical, Scoped |
 | **GitHub Gists** | `github-gist` | GitHub REST API | Incremental local index of own-account public and permitted secret Gist content/metadata; token not stored | Lexical (BM25), Local Semantic, Scoped |
 | **Cloud Drives** | `cloud-drive` | [`rclone`](https://rclone.org) CLI | Google Drive (Tier-1), OneDrive, Dropbox, etc. | Incremental Mirror + BM25 |
 | **Photos & Shots** | `clawgallery` | `clawgallery` CLI | Local screenshot and photo store | Hybrid OCR/Visual Search |
 | **RSS / News** | `rss` | Native HTTP Poller | RSS 2.0 & Atom feeds (24h deduplication) | Lexical |
 | **macOS Spotlight** | `spotlight` | Native `mdfind` CLI | macOS system metadata and content index | System Native |
+| **Browser History** | `hister` | [Hister](https://github.com/asciimoo/hister) server (AGPL-3.0-or-later, separate program, HTTP API) | Pages visited in Chrome/Chromium/Firefox, captured by Hister's own extension and indexed by Hister (web pages only; its local-file indexing is never used) | Lexical full-text; optional Semantic via Hister's own embedding endpoint |
 
 For configuration syntax and connector details, see [docs/datasource-skills.md](docs/datasource-skills.md). Non-interactive `sync`/`index` steps get a 30-minute per-connector budget (`connector.indexTimeoutMs`) because first-run imports routinely take minutes; interactive search keeps its 60-second default.
 
@@ -685,14 +723,14 @@ the defaults.
 
 Deep dive into AutoRAG Agent's architecture, security, and integration guides:
 
-- **[MinSync Setup & Embedding QA](docs/minsync-setup.md):** Automatic binary installation, CDC chunking, and local embedding verification.
-- **[Local Embedding Runtime & Gateway](docs/embedding-runtime.md):** AutoRAG-owned local gateway, model prefetching, and zero-egress semantic search. Model card: [`qwen3-embedding-0.6b`](docs/model-cards/qwen3-embedding-0.6b.md).
+- **[MinSync Setup & Embedding QA](docs/minsync-setup.md):** Automatic binary installation, CDC chunking, embedding backends (remote, `minsync serve` daemon, in-process addon), and local verification.
 - **[Hosted Dazzi Models Provider](docs/cloud-provider.md):** The hosted `dazzi` model provider — PKCE `/login`, `AUTORAG_BASE_URL`, live model discovery, and offline catalog snapshots.
+- **[Discord Remote Control](docs/discord.md):** Ask the librarian from a Discord channel through a running `autorag tui --discord` session: bot setup, permissions, and limits.
 - **[Telegram Remote Control](docs/telegram.md):** Ask the librarian from a Telegram chat through a running `autorag tui --telegram` session: setup, commands, and keeping it alive.
 - **[Datasource Skills Reference](docs/datasource-skills.md):** Full configuration contracts, connection aliases, and connector options.
+- **[Apple Calendar & Reminders via EventKit MCP](docs/eventkit-mcp.md):** macOS-only: read Calendar events and Reminders (Google/iCloud/Exchange accounts already in Calendar.app) by running `mcp-server-apple-events` beside `autorag-mcp`. Live, read-only; not indexed.
 - **[Jev Decisions](docs/jev-decisions.md):** Jev query pipeline, **on by default** via Dazzi Models when signed in (OpenRouter otherwise): it routes each question to a direct answer (intrinsic knowledge) or local search (everything needing more information; web search is left to the agent after the fast answer), splits multi-part questions into up to five parallel searches (`dazzi/openai/gpt-6-luna` when signed in, else `openrouter/qwen/qwen3.7-flash`), picks which registered datasources to search before the fast answer, and ends the run after the fast answer when that answer is complete. Also covers the `jev` judgment tool, backends (OpenRouter, TypeSafe, Vercel AI Gateway), and how to opt out.
 - **[Manual QA & Datasource Test Harnesses](docs/manual-qa-datasources.md):** Real-world testing guides for Discord, KakaoTalk, Slack, Notion, and email.
-- **[P2P SimpleX Sharing & Path Standard](docs/p2p-path-standard.md):** Decentralized peer query sharing with SimpleX, PII redaction, and approval queues.
 - **[Supply Chain Security & License Audits](docs/supply-chain.md):** Software bill of materials (SBOM) and dependency gate policies.
 - **[Competitive Landscape Study](docs/competitive-landscape-2026-09.md):** In-depth analysis of why in-place federation outperforms centralized RAG.
 - **[Legacy AutoRAG (AutoML)](legacy/README.md):** Documentation for the legacy Python AutoML pipeline optimizer (`pip install AutoRAG`).
@@ -714,26 +752,27 @@ AutoRAG Agent is an open-source project built by the community. We welcome contr
 AutoRAG Agent stands on the shoulders of fantastic open-source projects:
 
 - **[Pi Framework](https://github.com/earendil-works/pi-mono)** by [@earendil-works](https://github.com/earendil-works) — The foundational agent framework powering AutoRAG's reasoning loop.
-- **[MinSync](https://github.com/Marker-Inc-Korea/minsync)** — Ultra-fast incremental Change Data Capture (CDC) chunking and local BM25/vector indexing.
+- **[MinSync](https://github.com/Marker-Inc-Korea/minsync)** — Ultra-fast incremental Change Data Capture (CDC) chunking, local BM25/vector indexing, and the Qwen3-Embedding-0.6B embedding engine.
 - **[Jikji](https://github.com/NomaDamas/jikji)** by [NomaDamas](https://github.com/NomaDamas) — High-performance find-first local document discovery.
 - **[Everything](https://www.voidtools.com/)** and **[ES](https://github.com/voidtools/ES)** by voidtools (David Carpenter) — Instant Windows file-name indexing and its command-line interface, bundled under the MIT License.
 - **[FSearch](https://github.com/cboxdoerfer/fsearch)** and **[fsearch-cli](https://github.com/NomaDamas/fsearch-mac)** — Everything-style file-name search for macOS/Linux (GPL-2.0-or-later). Never bundled or linked: users install fsearch-cli separately and AutoRAG spawns it as a separate process (mere aggregation per the FSF GPL FAQ).
+- **[Hister](https://github.com/asciimoo/hister)** by [asciimoo](https://github.com/asciimoo) and contributors — Self-hosted browser web-history search (AGPL-3.0-or-later). Never bundled, linked, copied, or modified: users run Hister as a separate program and AutoRAG only calls its public HTTP search API (mere aggregation). Hister is always named as the backend of the `hister` datasource.
 - **[dupey](https://github.com/NomaDamas/dupey)** by [NomaDamas](https://github.com/NomaDamas) — Fast duplicate and near-duplicate document family detection.
-- **Federated CLI Authors:** External datasource tools [`lazykatok`](https://github.com/changeroa/lazykatok), [`discrawl`](https://github.com/openclaw/discrawl), [`mailcrawl`](https://github.com/NomaDamas/mailcrawl), [`wacrawl`](https://github.com/openclaw/wacrawl), [`telecrawl`](https://github.com/openclaw/telecrawl), [`slacrawl`](https://github.com/openclaw/slacrawl), [`notcrawl`](https://github.com/openclaw/notcrawl), [`qmd`](https://github.com/tobi/qmd), and [`rclone`](https://rclone.org).
+- **Federated CLI Authors:** External datasource tools [`lazykatok`](https://github.com/changeroa/lazykatok), [`discrawl`](https://github.com/openclaw/discrawl), [`mailcrawl`](https://github.com/NomaDamas/mailcrawl), [`wacrawl`](https://github.com/openclaw/wacrawl), [`telecrawl`](https://github.com/openclaw/telecrawl), [`slacrawl`](https://github.com/openclaw/slacrawl), [`notcrawl`](https://github.com/openclaw/notcrawl), and [`rclone`](https://rclone.org).
 - **[kordoc](https://github.com/chrisryugj/kordoc)** by [chrisryugj](https://github.com/chrisryugj) — HWP/HWPX/HWPML, PDF, DOCX and XLSX parsing with nested-table fidelity, used as AutoRAG's default document parser.
 
 ---
 
 ## Troubleshooting
 
-When search returns nothing, a datasource disappears from results, refresh hangs, or the gateway will not start, run the **`autorag-doctor`** agent skill (`skills/autorag-doctor/SKILL.md`). Point your coding agent at it and say *"check AutoRAG"* — it walks the full diagnose-and-repair procedure and ends with a per-datasource status table showing what is indexed and what actually returns hits.
+When search returns nothing, a datasource disappears from results, refresh hangs, or the embedder is unavailable, run the **`autorag-doctor`** agent skill (`skills/autorag-doctor/SKILL.md`). Point your coding agent at it and say *"check AutoRAG"* — it walks the full diagnose-and-repair procedure and ends with a per-datasource status table showing what is indexed and what actually returns hits.
 
 The first three commands cover most of it:
 
 ```bash
 autorag status --json          # freshness, per-component state, diagnostics
 autorag health --json          # model resolution + one live completion probe
-autorag gateway status --format json   # on-demand embedding runtime
+autorag setup                   # resolves the embedding backend and reports it
 ```
 
 Indexing is not the same thing as searchability, so always confirm retrieval
@@ -754,8 +793,8 @@ Common failures and their fix:
 | Symptom | Diagnostic code | Fix |
 |---|---|---|
 | Results are missing recent files | `stale-index` | `autorag refresh --method parsed,minsync --json` |
-| Semantic search returns nothing after changing the embedder | `embedding-identity-mismatch` | `autorag index rebuild --method minsync` |
-| Gateway will not start, a previous run was killed | `lock-conflict` | `autorag gateway stop`, then retry |
+| Semantic search returns nothing after changing the embedder, or after moving off the old embedding gateway | `embedding-identity-mismatch` | `autorag index rebuild --method minsync` |
+| No remote endpoint answers, no `minsync serve` daemon could start, and the in-process addon is missing or failed | `embedder-unavailable` | run `minsync serve` by hand to see its own error, install MinSync, install the optional `@nomadamas/minsync-native` addon, or configure a remote `minSync.embedder` |
 | A datasource is healthy in its own CLI but absent from results | — | confirm it is configured under `datasources` and connected through its native CLI |
 | A datasource errors during refresh | `datasource-index-failed` | run that CLI's own `doctor` |
 | MinSync binary missing (search and refresh fail with `MinSync is required ...`) | — | `cargo install minsync`, or leave `minSync.autoInstall` on and re-run refresh |
@@ -764,7 +803,7 @@ Common failures and their fix:
 | Windows file-name search fails during refresh | `everything-index-failed` | read the ES exit code and stderr in the message, then `autorag refresh --method everything --json` |
 | Every search does a full local search and verification, even for small talk | `query-route-fallback` | sign in to Dazzi Models with `/login`, or set `OPENROUTER_API_KEY` (Jev routing and decomposition are on by default) |
 
-Native datasource stores stay owned by their CLIs — AutoRAG never rebuilds them. Fix a broken archive with `lazykatok doctor`, `discrawl --json metadata`, `slacrawl --json doctor`, `wacrawl --json doctor`, `telecrawl --json doctor`, `notcrawl doctor`, `qmd status`, or `mailcrawl doctor`, then re-run `autorag refresh --method datasources --json`.
+Native datasource stores stay owned by their CLIs — AutoRAG never rebuilds them. Fix a broken archive with `lazykatok doctor`, `discrawl --json metadata`, `slacrawl --json doctor`, `wacrawl --json doctor`, `telecrawl --json doctor`, `notcrawl doctor`, or `mailcrawl doctor`, then re-run `autorag refresh --method datasources --json`.
 
 ---
 
@@ -775,3 +814,4 @@ Native datasource stores stay owned by their CLIs — AutoRAG never rebuilds the
 - Production third-party notices and licenses are documented in [`NOTICE`](NOTICE).
 - The bundled Windows binaries keep their own licenses: Everything (MIT, plus PCRE BSD-3-Clause) in [`licenses/everything-MIT-and-PCRE-BSD.txt`](licenses/everything-MIT-and-PCRE-BSD.txt) and ES (MIT) in [`licenses/es-MIT.txt`](licenses/es-MIT.txt). Everything's source code is not public; AutoRAG redistributes the unmodified voidtools portable ZIPs.
 - FSearch/fsearch-cli (GPL-2.0-or-later) are **not** distributed with AutoRAG: no code is copied, linked, or bundled. Users install fsearch-cli themselves and AutoRAG communicates with it only through its command-line interface and daemon socket — separate programs, per the [FSF mere-aggregation FAQ](https://www.gnu.org/licenses/gpl-faq.html#MereAggregation). Source: https://github.com/NomaDamas/fsearch-mac.
+- Hister (AGPL-3.0-or-later) is **not** distributed with AutoRAG: no Hister code is copied, linked, bundled, or modified. Users install an unmodified Hister release themselves and AutoRAG talks to that separate process only over its public HTTP API. Notice: [`licenses/hister-AGPL-3.0-notice.txt`](licenses/hister-AGPL-3.0-notice.txt). If you run Hister as a service for other people, AGPL section 13 applies to you as its operator.

package/dist/agent/agent.d.ts

@@ -3,17 +3,13 @@ import type { Api, ImageContent, Model } from "@earendil-works/pi-ai";
 import { type DatasourceRetryOptions } from "../datasource/retry.js";
 import type { DatasourceIndexResult, DatasourceSkill } from "../datasource/types.js";
 import { type DupeyCliOptions } from "../dupey/index.js";
-import { type Embedder } from "../embedding-runtime/gateway-embedder.js";
+import { type Embedder, type ManagedEmbedder } from "../embedding/index.js";
 import { type EverythingClientOptions, type EverythingSearchRequest, type EverythingSearchResult } from "../everything/index.js";
 import { type FSearchClientOptions, type FSearchFailureReason, type FSearchSearchRequest, type FSearchSearchResult } from "../fsearch/index.js";
 import { type JikjiFailureReason, type JikjiOptions, type JikjiPrepareOptions } from "../jikji/index.js";
 import { type LanguageTag } from "../language.js";
 import { type MinSyncSyncResult, type MinSyncVectorMethodOptions } from "../minsync/index.js";
 import { type ParsedMirrorSyncOptions, type ParsedMirrorSyncResult } from "../mirror/sync.js";
-import type { PolicyResolver } from "../p2p/policy-filter.js";
-import type { SimplexQueryState } from "../p2p/simplex-query-store.js";
-import { type SimplexTransport } from "../p2p/simplex-transport.js";
-import type { PeerQueryResponse } from "../p2p/wire.js";
 import { type DefaultParserRegistryOptions } from "../parser/index.js";
 import { RetrievalEngine } from "../retrieval/engine.js";
 import { RetrievalMethodRegistry } from "../retrieval/registry.js";
@@ -193,43 +189,20 @@ export interface AutoRAGWatchRefreshOptions {
     readonly watcherFactory?: WatcherFactory;
 }
 export type AutoRAGWatchRefreshHandle = WatchRefreshHandle;
-declare module "../retrieval/types.js" {
-    interface RetrievalOptions {
-        /** Server-only P2P policy identity; never included in model tool schemas. */
-        peerFingerprint?: string;
-        /** Server-only P2P policy resolver. */
-        resolvePolicy?: PolicyResolver;
-        /** Server-only run registry populated from observed retrieval output. */
-        observedSources?: Set<string>;
-        /** Server-only datasource source globs derived from the loaded policy. */
-        policyDatasourceScopes?: readonly string[];
-    }
-}
-export type RemoteSessionRejectionCode = "injection-detected" | "outbound-leak-detected";
-export declare class RemoteSessionRejectedError extends Error {
-    readonly code: RemoteSessionRejectionCode;
-    constructor(code: RemoteSessionRejectionCode);
-}
 /** Thinking level applied per search phase. "off" requests no reasoning. */
 export type AutoRAGThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 /**
  * Per-phase thinking for AutoRAG's two-phase search: the fast phase delivers
  * an immediate first answer with {@link AutoRAGThinkingOptions.fast} thinking
- * (default "off"), then the verification phase re-checks and finalizes with
+ * (default "minimal"), then the verification phase re-checks and finalizes with
  * {@link AutoRAGThinkingOptions.final} thinking (default "high").
  */
 export interface AutoRAGThinkingOptions {
-    /** Thinking level for the immediate first answer. Default "off". */
+    /** Thinking level for the immediate first answer. Default "minimal": some hosted models reject "off". */
     readonly fast?: AutoRAGThinkingLevel;
     /** Thinking level for the verification/finalization phase. Default "high". */
     readonly final?: AutoRAGThinkingLevel;
 }
-export interface PeerQueryOptions {
-    readonly port?: number;
-    readonly simplexDbPrefix?: string;
-    readonly openTransport?: () => Promise<SimplexTransport>;
-    readonly onResponse?: (state: SimplexQueryState, response: PeerQueryResponse) => void;
-}
 export interface AutoRAGAgentOptions {
     model?: Model<Api>;
     apiKey?: string;
@@ -269,7 +242,6 @@ export interface AutoRAGAgentOptions {
      * challenges. A self-hosted
      * SEARXNG_ENDPOINT is the only env-gated option. `false` disables both
      * tools. The `fetch` sub-option tunes or disables `web_fetch` alone.
-     * Web tools are always omitted for remote P2P sessions.
      */
     webSearch?: (WebSearchToolOptions & {
         fetch?: WebFetchToolOptions | false;
@@ -289,17 +261,22 @@ export interface AutoRAGAgentOptions {
      * probabilities out). When set, the two-phase search asks Jev before the
      * fast answer whether the question is answerable from intrinsic knowledge
      * (direct answer) or needs local search, and whether to decompose it; after the fast answer, whether
-     * verification is needed. It also exposes the `jev` tool. Always omitted for
-     * remote P2P sessions.
+     * verification is needed. It also exposes the `jev` tool.
      *
      * The CLI config enables this by default on OpenRouter (`buildAgentOptions`
      * fills it in). On this programmatic option, absent or `false` keeps Jev
      * off, so library callers never make paid network calls they did not ask for.
      */
     jev?: JevToolOptions | false;
+    /**
+     * The embedder shared by memory and the datasources. Omitted, it is built from `minSync.embedder`: a
+     * configured remote endpoint, else MinSync's `minsync serve` daemon, else MinSync's in-process engine.
+     * `refresh` brings it up (starting the daemon when none runs); a search only reads from it.
+     */
+    embedder?: ManagedEmbedder;
     /**
      * Embedder used to find similar past questions in memory (semantic half of
-     * the hybrid search). Defaults to the local embedding gateway; `false` keeps
+     * the hybrid search). Defaults to the shared {@link AutoRAGAgentOptions.embedder}; `false` keeps
      * memory search keyword-only.
      */
     memoryEmbedder?: Embedder | false;
@@ -308,7 +285,7 @@ export interface AutoRAGAgentOptions {
      * branch for questions about AutoRAG's own settings: the turn skips the
      * fast answer, receives the full `autorag-setup` skill, edits
      * `configPath` with the pi tools, and reports what it changed as its final
-     * message. Always omitted for remote P2P sessions.
+     * message.
      */
     selfConfig?: SelfConfigOptions;
     /**
@@ -347,12 +324,13 @@ export interface AutoRAGAgentOptions {
      */
     toolCallBurstGuard?: ToolBurstGuardOptions | false;
     /**
-     * Outbound SimpleX queries to trusted peer AutoRAG agents. Remote sessions
-     * never receive this tool.
+     * Control the interactive (TUI) session from Discord through the
+     * `pi-discord-remote` extension: a session channel is created on launch, and
+     * allowed users' messages run as questions; the final answer is posted back. Needs `~/.pi/agent/pi-discord-remote/config.json` (or
+     * `DISCORD_TOKEN` + `DISCORD_GUILD_ID`).
+     * Default false.
      */
-    peerQuery?: PeerQueryOptions | false;
-    /** Restrict the agent to retrieval and result-emission tools for remote runs. */
-    remoteSession?: boolean;
+    discordRemote?: boolean;
     /** Per-phase thinking levels for the two-phase (fast → verification) search. */
     thinking?: AutoRAGThinkingOptions;
     /** pi agent directory for auth/models/extensions. Defaults to ~/.pi/agent. */
@@ -367,6 +345,8 @@ export interface AutoRAGAgentOptions {
      * a launch.
      */
     updateNotice?: () => Promise<string | undefined>;
+    /** Interactive only: show the AutoRAG welcome banner (with this version) instead of pi's startup header. */
+    welcomeVersion?: string;
     /** Extension entry files (installed pi packages) loaded into the interactive session. */
     piExtensionPaths?: readonly string[];
     /** Flag values for the flags those extensions register. */
@@ -401,7 +381,7 @@ export interface AutoRAGSearchSession {
     readonly piSession?: AutoRAGPiSession["session"];
     prompt(text: string): Promise<void>;
     abort(): Promise<void> | void;
-    dispose(): void;
+    dispose(): void | Promise<void>;
 }
 export type AutoRAGJikjiPrepareResult = {
     readonly ok: true;
@@ -436,6 +416,8 @@ export declare class AutoRAGAgent {
      * state for `searchDocuments()` / `searchDocumentsStream()` callers.
      */
     private readonly interactive;
+    /** What the running search is doing, shown as a live widget in the TUI. */
+    private readonly searchProgress;
     /** Aborted by {@link abort} and by the run's timeout: gates publishing and the run's own requests. */
     private activeRunAbort;
     private modelNativeSearchAuth;
@@ -467,6 +449,8 @@ export declare class AutoRAGAgent {
     private readonly reranker;
     private readonly rerankTopN;
     private readonly minSyncMethod;
+    private readonly minSyncEmbedderConfig;
+    private readonly minSyncBinaryPath;
     private readonly jikjiClient;
     private readonly everythingClient;
     private readonly fsearchClient;
@@ -495,11 +479,13 @@ export declare class AutoRAGAgent {
     private readonly piSessionDir;
     private readonly persistPiSessions;
     private readonly updateNotice;
+    private readonly welcomeVersion;
     private readonly piExtensionPaths;
     private readonly piExtensionFlags;
     private readonly telegram;
     private boundPiRuntime;
     /** Embeds past questions for similar-question search; undefined keeps memory search keyword-only. */
+    private readonly embedder;
     private readonly memoryEmbedder;
     private readonly memoryVectorPath;
     /** Every retrieval result of the in-flight run with the query/method that surfaced it. */
@@ -510,8 +496,7 @@ export declare class AutoRAGAgent {
     private readonly conversationId;
     /** The memory context loaded for the in-flight run; cleared whenever a run starts. */
     private memoryContextCache;
-    /** True when this agent was constructed for an untrusted remote peer. */
-    readonly remoteSession: boolean;
+    private readonly discordRemote;
     private activeRetrievalOptions;
     private readonly toolBurstGuard;
     private readonly limits;
@@ -523,7 +508,7 @@ export declare class AutoRAGAgent {
      * this conversation, up to 25 similar past questions, and matching
      * long-term insights. Computed once per run (the datasource check and every
      * model turn share it) so the similar-question search and its embedder call
-     * are not repeated and a fallback is reported once. Remote peers never read it.
+     * are not repeated and a fallback is reported once.
      */
     private loadMemoryContextFor;
     private withMemoryContext;
@@ -550,7 +535,7 @@ export declare class AutoRAGAgent {
      * After the final answer: map every cited evidence back to the search query
      * and method that found it, ask Jev (one batched call, evidence judged in
      * parallel) whether it really supports the answer sentence it backs, and
-     * keep only what clears the threshold. Remote peers and runs without Jev
+     * keep only what clears the threshold. Runs without Jev
      * store nothing; a failed judgment stores nothing and says why.
      */
     private recordJudgedEvidence;
@@ -561,6 +546,12 @@ export declare class AutoRAGAgent {
     private currentSystemPromptConfig;
     subscribe(listener: Parameters<Agent["subscribe"]>[0]): () => void;
     createPiInteractiveRuntime(): Promise<AutoRAGPiInteractiveRuntime>;
+    /**
+     * Discord messages enter the same machinery as typed input: a new search when
+     * idle, a steer of the running one otherwise (queued as a follow-up question
+     * once the search can no longer take it).
+     */
+    private discordRemoteExtension;
     /**
      * The session's custom tools, with retrieval and web reads interruptible by a
      * steer: stopping them loses no side effect. bash and the file tools are pi
@@ -716,14 +707,20 @@ export declare class AutoRAGAgent {
      * `rerank.topN`. With decomposition the pool merges every search query's
      * hits (interleaved), capped at the same per-source sizes as a single query
      * so the rerank request does not grow with the query count. Returns
-     * `undefined` when reranking is disabled/unavailable or the pool is empty,
-     * so the caller keeps the unranked sections; a rerank failure never blocks
-     * the fast answer.
+     * `undefined` when reranking is disabled or the pool is empty. A configured
+     * reranker that is unavailable, throws, or returns nothing for a non-empty
+     * pool throws, so the caller can report it and fall back.
      */
     private rerankPrefetchPool;
+    /**
+     * Surface a rerank failure the way a model error is surfaced: a diagnostic on
+     * the response and, in the TUI, a visible notice in the transcript. The run
+     * continues on the retrieval-order fallback.
+     */
+    private reportRerankFailure;
     /**
      * Fast-phase prompt for two-phase searches. The baseline retrieval context
-     * is already gathered, so the model answers immediately with thinking off,
+     * is already gathered, so the model answers immediately with minimal thinking,
      * as plain text, without any further tool calls.
      */
     buildFastAnswerPrompt(query: string, options: RetrievalOptions, baseline: string): string;
@@ -756,6 +753,11 @@ export declare class AutoRAGAgent {
     buildRefinementPrompt(query: string, options: RetrievalOptions, fastAnswer: string | undefined, fastAnswerDelivered: boolean, steers?: readonly string[]): string;
     buildSearchPrompt(query: string, options: RetrievalOptions, initialRetrievalContext?: string): string;
     refresh(force?: boolean, opts?: AutoRAGRefreshOptions): Promise<AutoRAGRefreshResult>;
+    /**
+     * One warning when nothing can embed, so semantic search is not silently lexical-only. The text names the
+     * way out; AutoRAG does not start the daemon itself. Shown by `status`, `lite status`, and the MCP status tool.
+     */
+    private embeddingDiagnostics;
     /**
      * Path-opaque snapshot of corpus freshness and the last refresh outcome. Runs
      * a cheap parse-free staleness scan (stat only); never parses in this path.

package/dist/agent/answer-guidelines.d.ts

@@ -10,6 +10,27 @@ export declare const ANSWER_IMAGE_EMBED_RULE = "**Images**: when a retrieved res
  * already showed.
  */
 export declare const ANSWER_IMAGE_DELTA_RULE = "An image already embedded in the first answer must not be embedded again.";
+/**
+ * Answer readability rules. Every surface that tells the model how to write the
+ * answer (system prompt, fast/complete/delta/search phase prompts, report
+ * schema) carries the same wording, so the answer's shape does not depend on
+ * which phase produced it. Each rule yields to an explicit user request for a
+ * different format.
+ */
+/**
+ * Conclusion first. Only complete answers get a lead line: a delta answer holds
+ * only corrections and new findings, and a lead conclusion would restate the
+ * first answer. The lead is outside the 5-bullet cap so the cap stays intact.
+ */
+export declare const ANSWER_LEAD_RULE = "**Lead with the conclusion**: unless the user explicitly requests a different format, start the answer with one line that states the conclusion in **bold**, followed by the supporting bullet points. The lead line is not counted in the 5-bullet cap. When the whole answer is a single fact, the lead line alone is enough and no bullets are needed.";
+/** One claim per bullet; flat list. */
+export declare const ANSWER_BULLET_RULE = "**One claim per bullet**: each bullet makes one claim in one or two sentences. Never nest bullets; split a bullet that carries two claims into two bullets.";
+/** Bold the values a reader scans for; tabulate real comparisons. */
+export declare const ANSWER_EMPHASIS_RULE = "**Emphasis**: put the values a reader scans for (dates, amounts, names, statuses, deadlines) in **bold**, and nothing else. When comparing three or more items across the same attributes, use a markdown table instead of bullets.";
+/** Answer language follows the question, not the sources. */
+export declare const ANSWER_LANGUAGE_RULE = "**Answer language**: write the answer in the language of the user's question (a Korean question gets a Korean answer) even when the sources are in another language; if the user asks for a specific language, use that one. Keep proper nouns, identifiers, code, and terms quoted from sources in their original form.";
+/** Uncertainty goes last so it never buries the conclusion. */
+export declare const ANSWER_UNCERTAINTY_RULE = "**Uncertainty placement**: when the answer is incomplete or uncertain, state that in one short sentence on the last line of the answer, never before or ahead of the conclusion. Do not hedge the conclusion itself.";
 /**
  * Inline evidence citations. The model writes the id the retrieval tools print
  * next to each result; the harness resolves it to the recorded source and
@@ -27,7 +48,7 @@ export declare const ANSWER_CITATION_RULE = "**Citations**: cite supporting evid
  * concise by stating the created file's location and briefly summarizing what
  * was generated (citing only the underlying source evidence).
  */
-export declare const ANSWER_DELIVERABLE_RULE = "**Deliverables and artifacts**: if the user asks you to draft, write, generate, or prepare a deliverable or artifact (a reply email, letter, legal opinion, summary document, standard-format case citation block, checklist, report, or workflow document \u2014 including requests phrased as \"how should I reply...\" to a specific message), produce the finished, ready-to-use artifact as a file (using `write`, `edit`, or `bash` in local sessions, without overwriting existing source files) in a file format, extension, and structure aligned with the context and domain (e.g. `.eml` or `.md`/`.txt` with headers for an email reply; `.md`, `.txt`, `.docx`, `.hwp`, or `.pdf` matching workspace conventions for a legal opinion, insertable case-citation block, or summary document; `.csv`, `.xlsx`, or `.json` for structured tabular data), containing the complete unabridged artifact (including required headers, precedent passages, pinpoint paragraphs, and standard-format citations) inside the file instead of merely describing how to produce it. Do NOT dump the full artifact text into your reply: unless the user explicitly requests otherwise, keep your reply concise within the at-most-5-bullet direct-answer format, clearly stating the created file's exact path/location and briefly summarizing what was generated with inline citations to the underlying source evidence (`[eN]` or `[file:<source path>]`); never cite the newly created deliverable file itself as `[file:...]`.";
+export declare const ANSWER_DELIVERABLE_RULE = "**Deliverables and artifacts**: if the user asks you to draft, write, generate, or prepare a deliverable or artifact (a reply email, letter, legal opinion, summary document, standard-format case citation block, checklist, report, or workflow document \u2014 including requests phrased as \"how should I reply...\" to a specific message), produce the finished, ready-to-use artifact as a file (using `write`, `edit`, or `bash` in local sessions) in a file format, extension, and structure aligned with the context and domain (e.g. `.eml` or `.md`/`.txt` with headers for an email reply; `.md`, `.txt`, `.docx`, `.hwp`, or `.pdf` matching workspace conventions for a legal opinion, insertable case-citation block, or summary document; `.csv`, `.xlsx`, or `.json` for structured tabular data), containing the complete unabridged artifact (including required headers, precedent passages, pinpoint paragraphs, and standard-format citations) inside the file instead of merely describing how to produce it. Do NOT dump the full artifact text into your reply: unless the user explicitly requests otherwise, keep your reply concise within the at-most-5-bullet direct-answer format, clearly stating the created file's exact path/location and briefly summarizing what was generated with inline citations to the underlying source evidence (`[eN]` or `[file:<source path>]`); never cite the newly created deliverable file itself as `[file:...]`.";
 /**
  * Verification-phase deliverable rule: create the context-aligned deliverable
  * file (in local sessions) and report its location and concise summary if the