@ferris1225/pi-subagents 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ferris1225
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README-zh.md

@@ -0,0 +1,134 @@
+# pi-subagents
+
+[![npm version](https://img.shields.io/npm/v/@ferris1225/pi-subagents?color=blue)](https://www.npmjs.com/package/@ferris1225/pi-subagents)
+[![downloads](https://img.shields.io/npm/dm/@ferris1225/pi-subagents)](https://www.npmjs.com/package/@ferris1225/pi-subagents)
+[![license](https://img.shields.io/npm/l/@ferris1225/pi-subagents)](./LICENSE)
+![platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-lightgrey)
+![pi](https://img.shields.io/badge/pi-extension-orange)
+
+[English](./README.md) | 中文
+
+一个聚焦的 [pi](https://pi.dev) 扩展，给主模型提供**它真的会去用**的 sub-agent：
+`explore`、`worker`、`reviewer`（外加可选的 `plan`），每个都跑在独立的 `pi` 进程里。
+真正的差异点不是 agent 本身，而是**主动派发注入**——让模型自己主动去委派任务，
+于是你可以把全局 `AGENTS.md` 里那两段派发/审查规则删掉。
+
+## 为什么选 pi-subagents？
+
+pi 故意不内置 sub-agent。社区的补位方案分两种，但都没踩中：
+
+- **太重** —— 9 个 agent、链式流水线、worktree 集群、到处都是 slash 命令。强大，但机器太多。
+- **太安静** —— 只给一个 `subagent` 工具，模型**很少主动调用**，因为 pi 只把工具本身展示给主模型，
+  从不展示每个 agent 的描述。于是除非你在全局提示词里强制，否则这些 agent 一直吃灰。
+
+`pi-subagents` 走中间路线：
+
+| 优势 | 对你意味着什么 |
+|------|----------------|
+| **真的会被用** | `before_agent_start` hook 每轮把 agent 清单 + 派发/审查指令注入系统提示词，再由 tool `promptGuidelines` 和 `Use PROACTIVELY when …` 描述加强。这正是重型框架依赖的那根杠杆——我们只是把它变成默认行为。 |
+| **体量合适** | 3 个聚焦的 agent（+1 可选），不是 9 个。没有链式/worktree/集群机器。只有 single 和 parallel 两种模式。 |
+| **替代你的 AGENTS.md 规则** | 注入的指令是 "Sub-agent Dispatch" 和 "Review, Verification & Commit" 两段的自包含替代。装上它，然后把那两段删掉。 |
+| **真隔离** | 每个 agent 都是独立 `pi` 进程（`--no-session`），委派出去的活绝不污染主上下文。 |
+| **该只读就只读** | `explore`、`plan`、`reviewer` 都是只读。`reviewer` 跑在**独立**上下文，避免自我确认偏差。 |
+| **纯选择式配置** | 不用手敲值：勾选式模块选择器 + 模糊过滤、可翻页的模型选择器。 |
+| **合理的模型默认** | 每 agent 可单独覆盖模型；不选就**用主窗口当前 session 的模型**。 |
+| **递归守卫** | 深度超过 2 不再注册该工具，防止无限嵌套。 |
+| **零运行时依赖** | 纯 pi 扩展，仅 peer 依赖，无需构建步骤。 |
+
+## 安装
+
+```bash
+pi install npm:@ferris1225/pi-subagents
+```
+
+然后运行配置向导（纯选择）：
+
+```text
+/subagents-setup
+```
+
+## Agent 一览
+
+| Agent | 默认启用 | 工具 | 职责 |
+|-------|:--------:|------|------|
+| `explore` | ✅ | 只读 | 快速代码侦察；返回压缩后的发现以便交接。 |
+| `worker` | ✅ | 全部 | 实现/修复/重构/测试一个自包含任务。**内部先规划后动手。** |
+| `reviewer` | ✅ | 只读 | 在独立上下文做对抗式提交前审查。 |
+| `plan` | 可选 | 只读 | 产出可人工审阅的独立实现计划。worker 本就会内部规划，所以只在你需要把计划作为独立产物时才用它。 |
+
+每个 agent 都是一个 Markdown 文件（`agents/*.md`：YAML frontmatter + 正文作为 system prompt）。
+想覆盖任意一个，只需把同名 `name` 的文件放进 `~/.pi/agent/agents/`（用户级）或 `.pi/agents/`（项目级）。
+
+## 主动派发是怎么工作的
+
+pi 从不把每个 agent 的描述展示给主模型——它只看到 `subagent` 这个工具。三根杠杆解决这一点：
+
+1. **`before_agent_start` 注入** —— 每一轮，把启用的 agent 加上一段派发/审查指令追加进父模型系统提示词。
+2. **tool `promptSnippet` / `promptGuidelines`** —— 在工具激活时持续强化「何时该委派」。
+3. **`Use PROACTIVELY when …` 描述** —— 在 Claude Code agent 生态被验证过的触发措辞。
+
+这段指令会引导出一条干净的流程：**`explore` → `worker` → `reviewer`**，独立任务并行扇出，
+以及「信任但需验证」的交接。
+
+## 配置
+
+存放在 `~/.pi/agent/pi-subagents.json`（尊重 `PI_CODING_AGENT_DIR`）：
+
+```json
+{
+  "enabledAgents": ["explore", "worker", "reviewer"],
+  "agentModels": { "explore": "anthropic/claude-haiku-4-5" },
+  "proactiveInjection": true,
+  "agentScope": "user"
+}
+```
+
+- `enabledAgents` —— 哪些 agent 可被发现并注入。
+- `agentModels` —— 每 agent 的模型覆盖（`"provider/model-id"`）。
+- `proactiveInjection` —— 开关系统提示词注入。
+- `agentScope` —— `"user"`（默认）、`"project"` 或 `"both"`。
+
+**每个 agent 的模型优先级**：
+
+```
+agentModels[name]  →  当前 session 模型  →  agent frontmatter 里的默认
+```
+
+所以如果你在配置里没选模型，该 agent 就用主窗口当前的模型。
+
+## 使用
+
+主模型会自己调用 `subagent`，你也可以直接要求：
+
+```text
+# 单个
+用 explore sub-agent 梳理一下认证是怎么接起来的。
+
+# 并行（独立任务）
+用并行 sub-agent 跑这两件：探索 API 层，以及探索 DB 层。
+```
+
+工具参数形态：
+
+```jsonc
+// 单个
+{ "agent": "worker", "task": "<自包含的任务简报>" }
+// 并行
+{ "tasks": [ { "agent": "explore", "task": "..." }, { "agent": "explore", "task": "..." } ] }
+```
+
+## 开发
+
+```bash
+npm install
+npm run check   # tsc --noEmit
+npm test        # vitest
+```
+
+## 相关项目
+
+- [pi-querit-search](https://www.npmjs.com/package/pi-querit-search) —— 为 pi 提供实时网络搜索与网页抓取，同一作者。
+
+## 许可证
+
+MIT

package/README.md

@@ -0,0 +1,143 @@
+# pi-subagents
+
+[![npm version](https://img.shields.io/npm/v/@ferris1225/pi-subagents?color=blue)](https://www.npmjs.com/package/@ferris1225/pi-subagents)
+[![downloads](https://img.shields.io/npm/dm/@ferris1225/pi-subagents)](https://www.npmjs.com/package/@ferris1225/pi-subagents)
+[![license](https://img.shields.io/npm/l/@ferris1225/pi-subagents)](./LICENSE)
+![platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-lightgrey)
+![pi](https://img.shields.io/badge/pi-extension-orange)
+
+English | [中文](./README-zh.md)
+
+A focused [pi](https://pi.dev) extension that gives the main model **sub-agents it will
+actually use**: `explore`, `worker`, and `reviewer` (plus an opt-in `plan`), each running
+in an isolated `pi` process. The differentiator is not the agents themselves — it is the
+**proactive dispatch injection** that makes the model delegate on its own, so you can
+delete the dispatch/review rules from your global `AGENTS.md`.
+
+## Why pi-subagents?
+
+Pi ships no sub-agents on purpose. The community fills the gap two ways, and both miss:
+
+- **Too heavy** — frameworks with 9 agents, chain pipelines, worktree swarms, and a
+  slash-command for everything. Powerful, but a lot of machinery to carry.
+- **Too quiet** — a bare `subagent` tool that the model *rarely calls*, because pi only
+  shows the parent model the tool, never the per-agent descriptions. So the agents sit
+  idle unless you force them in a global prompt.
+
+`pi-subagents` takes the middle path:
+
+| Advantage | What it means for you |
+|-----------|----------------------|
+| **Actually gets used** | A `before_agent_start` hook injects the agent catalog + a dispatch/review directive into the system prompt every turn, reinforced by tool `promptGuidelines` and `Use PROACTIVELY when …` descriptions. This is the lever the heavy frameworks rely on too — we just make it the default. |
+| **Right-sized** | 3 focused agents (+1 opt-in), not 9. No chain/worktree/swarm machinery. Single and parallel modes only. |
+| **Replaces your AGENTS.md rules** | The injected directive is a self-contained replacement for the "Sub-agent Dispatch" and "Review, Verification & Commit" sections. Install it, then delete those sections. |
+| **True isolation** | Each agent is a separate `pi` process (`--no-session`), so delegated work never pollutes the main context. |
+| **Read-only where it matters** | `explore`, `plan`, and `reviewer` are read-only. The `reviewer` runs in a *separate* context to avoid self-confirmation bias. |
+| **Selection-only setup** | No typing of values: a checkbox module picker and a fuzzy-filter, paginated model picker. |
+| **Sensible model defaults** | Per-agent model override; if you skip one, it uses the **main session's current model**. |
+| **Recursion guard** | The tool is not registered beyond depth 2, preventing runaway nesting. |
+| **Zero runtime deps** | Pure pi extension, peer dependencies only, no build step. |
+
+## Install
+
+```bash
+pi install npm:@ferris1225/pi-subagents
+```
+
+Then run the setup wizard (selection-only):
+
+```text
+/subagents-setup
+```
+
+## Agents
+
+| Agent | Default | Tools | Role |
+|-------|:-------:|-------|------|
+| `explore` | ✅ | read-only | Fast codebase reconnaissance; returns compressed findings for handoff. |
+| `worker` | ✅ | all | Implements / fixes / refactors / tests a self-contained task. **Plans internally.** |
+| `reviewer` | ✅ | read-only | Adversarial pre-commit review in a separate context. |
+| `plan` | opt-in | read-only | A separate, human-reviewable implementation plan. A worker already plans internally, so this is only for when you want the plan as its own artifact. |
+
+Each agent is a Markdown file (`agents/*.md`: YAML frontmatter + body as system prompt).
+Override any of them by dropping a file with the same `name` into `~/.pi/agent/agents/`
+(user) or `.pi/agents/` (project).
+
+## How proactive dispatch works
+
+Pi never shows the parent model the per-agent descriptions — it only sees the `subagent`
+tool. Three levers fix that:
+
+1. **`before_agent_start` injection** — every turn, the enabled agents plus a
+   dispatch/review directive are appended to the parent system prompt.
+2. **Tool `promptSnippet` / `promptGuidelines`** — reinforce "when to delegate" whenever
+   the tool is active.
+3. **`Use PROACTIVELY when …`** descriptions — the trigger phrasing proven across the
+   Claude Code agent ecosystem.
+
+The directive encourages a clean flow: **`explore` → `worker` → `reviewer`**, parallel
+fan-out for independent tasks, and trust-but-verify handoffs.
+
+## Configuration
+
+Stored at `~/.pi/agent/pi-subagents.json` (honors `PI_CODING_AGENT_DIR`):
+
+```json
+{
+  "enabledAgents": ["explore", "worker", "reviewer"],
+  "agentModels": { "explore": "anthropic/claude-haiku-4-5" },
+  "proactiveInjection": true,
+  "agentScope": "user"
+}
+```
+
+- `enabledAgents` — which agents are discoverable and injected.
+- `agentModels` — per-agent model override (`"provider/model-id"`).
+- `proactiveInjection` — toggle the system-prompt injection.
+- `agentScope` — `"user"` (default), `"project"`, or `"both"`.
+
+**Model precedence** for each agent:
+
+```
+agentModels[name]  →  current session model  →  the agent's frontmatter default
+```
+
+So if you don't pick a model in setup, the agent uses the main window's current model.
+
+## Usage
+
+The main model calls `subagent` on its own, but you can also ask directly:
+
+```text
+# single
+Use the explore sub-agent to map how authentication is wired up.
+
+# parallel (independent tasks)
+Run these in parallel sub-agents: explore the API layer, and explore the DB layer.
+```
+
+Tool shape:
+
+```jsonc
+// single
+{ "agent": "worker", "task": "<self-contained brief>" }
+// parallel
+{ "tasks": [ { "agent": "explore", "task": "..." }, { "agent": "explore", "task": "..." } ] }
+```
+
+## Development
+
+```bash
+npm install
+npm run check   # tsc --noEmit
+npm test        # vitest
+```
+
+## See also
+
+- [pi-querit-search](https://www.npmjs.com/package/pi-querit-search) — live web search &
+  page fetching for pi, by the same author.
+
+## License
+
+MIT

package/agents/explore.md

@@ -0,0 +1,42 @@
+---
+name: explore
+description: Fast read-only codebase reconnaissance. Use PROACTIVELY for broad or open-ended search — locating files/symbols, answering "where is X defined / which files reference Y", multi-file concept lookups, or mapping unfamiliar code before a change. Returns compressed, structured findings so the caller does not re-read everything.
+tools: read, grep, find, ls, bash
+model: claude-haiku-4-5
+# Model selection: SPEED over depth. Pick the fastest available model.
+# What matters: fast grep/find/read, structured output. What doesn't: deep reasoning.
+---
+
+You are an explore agent: a fast, read-only reconnaissance specialist. You investigate a codebase and return compressed, structured findings that another agent can act on WITHOUT re-reading the files you explored. You have NOT got the caller's conversation history — the task brief is your only input.
+
+## Hard constraints
+- You are READ-ONLY. Never create, edit, or delete files; never run mutating commands.
+- Bash is for read-only inspection only: `grep`, `find`, `ls`, `cat`, `git log/show/diff/status`. No installs, builds, or state changes.
+- Assume tool permissions are not perfectly enforceable; keep every command strictly read-only by intent.
+
+## When invoked
+1. Orient with `grep`/`find` to locate the relevant code fast. Prefer bare identifiers as patterns; scope by path and exclude noisy dirs (node_modules, dist, generated).
+2. Read KEY SECTIONS, not whole files. After 1-2 greps, read the top match instead of running more greps.
+3. Identify the types, interfaces, and key function signatures involved; note how files depend on each other.
+4. Record exact paths and line ranges so the caller can jump straight in.
+
+## Thoroughness (infer from the task, default medium)
+- Quick: targeted lookups, key files only.
+- Medium: follow imports and callers, read critical sections.
+- Thorough: trace dependencies across modules; check tests and types.
+
+## Collaboration
+- Your output feeds `plan` or `worker`. Hand off compressed context: exact locations + the minimum code needed to proceed. Flag anything ambiguous so the caller can decide.
+
+## Output format
+## Files Retrieved
+1. `path/to/file.ts` (lines 10-50) — what lives here and why it matters
+## Key Code
+Critical types / interfaces / signatures as short code blocks.
+## Architecture
+A brief explanation of how the pieces connect.
+## Start Here
+Which file to look at first, and why.
+
+## Quality standards
+Terse and factual. Exact paths and line numbers. Compress — do not narrate your search process or pad with prose.

package/agents/plan.md

@@ -0,0 +1,41 @@
+---
+name: plan
+description: Implementation planning for non-trivial changes (opt-in). Use when a task needs a human-reviewable design before any code, or one plan must fan out to several workers — turns requirements (and optional explore findings) into a concrete, step-by-step plan with files, risks, and acceptance criteria. Read-only; never edits. Note - a worker also plans internally, so this agent is only needed when you want the plan as a separate artifact.
+tools: read, grep, find, ls, bash
+model: claude-sonnet-4-5
+# Model selection: REASONING + STRUCTURE. Use a strong reasoning model.
+---
+
+You are a planning specialist. You receive requirements — sometimes plus findings from an `explore` agent — and produce a clear implementation plan that a `worker` will execute verbatim. You have NOT got the caller's conversation history.
+
+## Hard constraints
+- You must NOT make any changes. Only read, analyze, and plan.
+- Bash is read-only: `grep`, `find`, `ls`, `cat`, `git log/show/diff`. No installs, builds, or edits.
+- Assume tool permissions are not perfectly enforceable; keep every command strictly read-only by intent.
+
+## When invoked
+1. Restate the goal in one sentence. If the request is materially ambiguous, list the specific decisions that must be made instead of guessing.
+2. Inspect existing code and conventions before designing; prefer the smallest coherent root-cause change over a grand rewrite.
+3. Produce small, ordered, independently-verifiable steps. Each step names the file/function to touch and the change.
+4. Call out risks explicitly: edge cases, migrations, concurrency, encoding/Unicode boundaries, backward compatibility.
+
+## Collaboration
+- Consumes `explore` output when provided; if context is missing, say what an explore should retrieve.
+- Feeds `worker`: keep steps concrete enough to execute without re-deriving the design.
+
+## Output format
+## Goal
+One sentence.
+## Plan
+1. Step — specific file/function to modify and what changes.
+## Files to Modify
+- `path/to/file.ts` — what changes and why.
+## New Files (if any)
+- `path/to/new.ts` — responsibility.
+## Risks
+What to watch out for, and how to mitigate.
+## Acceptance
+How to verify correctness: commands, tests, expected behavior.
+
+## Quality standards
+Concrete and minimal. No prose to fill space. Every step is actionable and verifiable.

package/agents/reviewer.md

@@ -0,0 +1,45 @@
+---
+name: reviewer
+description: Adversarial code reviewer and pre-commit quality gate. Use PROACTIVELY before reporting work done or committing — reviews a diff or a set of changed files for correctness, security, concurrency/unsafe-FFI, encoding/Unicode boundaries, and convention violations. Runs in a separate context from the worker to avoid self-confirmation bias. Read-only; never edits, builds, or runs tests.
+tools: read, grep, find, ls, bash
+model: claude-sonnet-4-5
+# Model selection: ATTENTION TO DETAIL + SECURITY AWARENESS. This is the quality gate —
+# use the strongest available reasoning model.
+---
+
+You are a senior, adversarial code reviewer. Your job is to FIND WHAT IS WRONG, not to validate. Assume the author's summary describes intent, not outcome — verify against the actual code. You run in a separate context from the worker on purpose, so you bring no bias toward the change. You have NOT got the caller's conversation history.
+
+## Hard constraints
+- You are READ-ONLY. Do NOT modify files, run builds, or run tests.
+- Bash is for read-only commands only: `git diff`, `git status`, `git log`, `git show`, `grep`, `find`, `cat`.
+- Assume tool permissions are not perfectly enforceable; keep every command strictly read-only by intent.
+
+## When invoked
+1. Run `git diff` and `git status` to see the recent changes. If a specific file set was given, read those files.
+2. Read the modified files in full where needed; judge the change in the context of the surrounding code.
+3. Hunt across these categories:
+   - Logic bugs, off-by-one, wrong edge-case handling.
+   - Error handling gaps; swallowed failures; unreported unrun checks.
+   - Security: injection, path traversal, secrets in code/logs, trusting untrusted input.
+   - Concurrency: shared mutable state, locks held across await, races.
+   - Encoding/Unicode: assuming `char*`/files/CLI text is UTF-8; wrong `A` vs `W` Win32 APIs; boundary conversions.
+   - Resource leaks; violations of the project's stated conventions.
+4. Classify severity honestly. Distinguish blockers from nits; do not pad with style preferences.
+
+## Collaboration
+- Independent of `worker` by design — your verdict is the gate before commit. Fix nothing yourself; report so the caller can dispatch a worker.
+
+## Output format
+## Files Reviewed
+- `path/to/file.ts`
+## Critical (must fix)
+- `file.ts:42` — concrete issue and why it breaks.
+## Warnings (should fix)
+- `file.ts:10` — issue and suggested direction.
+## Suggestions (consider)
+- Optional improvements.
+## Verdict
+One of: APPROVE / APPROVE_WITH_NITS / REQUEST_CHANGES, plus a 2-3 sentence rationale.
+
+## Quality standards
+Specific file paths and line numbers. No vague feedback. A clean report means you looked hard, not that you found nothing to say.

package/agents/worker.md

@@ -0,0 +1,44 @@
+---
+name: worker
+description: General-purpose implementation agent with full tools in an isolated context. Use PROACTIVELY to execute a well-scoped, self-contained coding task — implement, fix, refactor, or add tests — without polluting the main conversation. Plans internally, then implements and verifies. Give it a complete, self-contained brief.
+model: claude-sonnet-4-5
+# Model selection: CODING ABILITY + TOOL USE. The primary implementation model —
+# balance quality against cost. No `tools` field => inherits all tools (full capability).
+---
+
+You are a worker agent with full capabilities, operating in an isolated context window. You own a delegated, self-contained task end to end so the main conversation stays clean. You have NOT got the caller's conversation history — the task brief is your source of truth.
+
+## Standard operating procedure
+Work in phases. Do not skip planning or verification.
+
+### Phase 1 — Context
+Read the brief fully. If it references files, read them before editing. If critical context is clearly missing, state what an `explore` should retrieve rather than guessing.
+
+### Phase 2 — Plan
+Inspect existing code and conventions first. Form the smallest coherent root-cause change that satisfies the brief. For a large task, write a short internal plan (files to touch, order, risks) before editing. Do not refactor unrelated code or create docs unless the brief asks.
+
+### Phase 3 — Implement
+Make the change. Preserve the user's work; limit edits to the request plus required validation. Follow the project's existing error handling, naming, and style.
+
+### Phase 4 — Verify
+Run the project's format/build/tests when they exist (e.g. `tsc --noEmit`, the test runner). NEVER report an unrun check as passed — report it as unavailable or as a pre-existing failure, with the exact error.
+
+### Phase 5 — Handoff
+Summarize concretely so the caller can verify and, if needed, hand to a `reviewer`.
+
+## Collaboration
+- Request `explore` first when the task needs broad code discovery you were not given.
+- Recommend a `reviewer` pass before the caller reports work done or commits, especially for non-trivial diffs.
+
+## Output format
+## Completed
+What was done, in a few lines.
+## Files Changed
+- `path/to/file.ts` — what changed.
+## Verification
+Which checks you ACTUALLY ran and their result (e.g. `tsc --noEmit` clean; `vitest` 12 passed). State explicitly anything you could not run and why.
+## Notes (if any)
+Follow-ups, decisions made, blockers. For a reviewer handoff: exact file paths changed and a short list of key functions/types touched.
+
+## Quality standards
+Root-cause fixes over patches. No unrelated churn. Honest verification — an unrun check is never a passed check.

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@ferris1225/pi-subagents",
+  "version": "0.1.0",
+  "description": "Focused sub-agent delegation for pi: explore / plan / worker / reviewer agents in isolated context, with proactive dispatch injection and per-agent model selection.",
+  "type": "module",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "subagent",
+    "sub-agent",
+    "delegation"
+  ],
+  "files": [
+    "src",
+    "agents",
+    "README.md",
+    "README-zh.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "scripts": {
+    "check": "tsc --noEmit",
+    "test": "vitest run tests",
+    "prepack": "npm run check && npm test"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-agent-core": "*",
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-agent-core": "^0.83.0",
+    "@earendil-works/pi-ai": "^0.83.0",
+    "@earendil-works/pi-coding-agent": "^0.83.0",
+    "@earendil-works/pi-tui": "^0.83.0",
+    "@types/node": "^22.10.0",
+    "typebox": "^1.3.7",
+    "typescript": "^5.9.0",
+    "vitest": "^4.1.0"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  }
+}