billion-context-pi 0.0.1 → 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ranxianglei
+
+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.md

@@ -1,38 +1,174 @@
-# billion-context-pi
+# pai-acp
 
-> One billion, not one million. Model-driven context management for the Pi coding agent.
+[English](./README.md) | [中文](./README.zh-CN.md)
 
-**Status: 0.0.1 placeholder.** This package reserves the name for the upcoming rename of [`pai-acp`](https://github.com/ranxianglei/pai-acp). The first real release under this name is coming soon.
+<p align="center">
+<strong>Active Context Pruning</strong> for <a href="https://pi.dev">Pi</a>
+<br />
+The model decides <em>when</em> and <em>what</em> to compress — not a hard limit.
+</p>
 
-## What it will be
+---
 
-The Pi extension for `billion-context` — model-driven context management that compresses long-running coding agent sessions from hundreds of millions of tokens down to a stable working set (~140K), keeping the prefix cache warm and preserving every detail via searchable, reversible summaries.
+<p align="center">
+<a href="https://www.npmjs.com/package/pai-acp"><img src="https://img.shields.io/npm/v/pai-acp.svg?style=flat-square" alt="npm"></a>
+<a href="https://github.com/ranxianglei/pai-acp/blob/master/LICENSE"><img src="https://img.shields.io/npm/l/pai-acp.svg?style=flat-square" alt="license"></a>
+<a href="https://github.com/ranxianglei/pai-acp"><img src="https://img.shields.io/badge/GitHub-ranxianglei%2Fpai--acp-181717?style=flat-square&logo=github" alt="GitHub"></a>
+</p>
 
-## Features (shipping today as `pai-acp`)
+<p align="center">
+<code>pi install npm:pai-acp</code>
+</p>
 
-- **compress** — Replace consumed conversation ranges with dense, self-contained summaries.
-- **decompress** — Restore previously compressed blocks on demand.
-- **search_context** — Search compressed block summaries by keyword.
-- **acp_status** — Context status overview with compressible ranges.
-- **acp_delegate** — Delegate tasks to fresh sub-agents in a clean context.
+---
+
+## Why?
+
+When conversations get long, the model runs out of context. Most tools hard-truncate — silently dropping earlier messages. **ACP** gives the model a `compress` tool: the LLM decides **when** and **what** to compress into high-fidelity summaries, preserving critical details (file paths, decisions, error strings) while reclaiming context space.
+
+Unlike Pi's built-in auto-compaction (which replaces everything with a single summary), ACP:
+- **Preserves structure** — compressed ranges become labeled blocks you can decompress later
+- **Multi-tier** — summaries can be further distilled (T1 → T2 → T3) as sessions grow
+- **Searchable** — `search_context` finds information inside compressed blocks without decompressing
+- **Selective** — protected tools, user messages, and the recent working set are never compressed
+
+This means:
+
+1. **A single session handles enormous workloads.** Per simulation tests of the three-tier architecture (see [opencode-acp](https://github.com/ranxianglei/opencode-acp)), one session can process on the order of 10–60 billion cumulative tokens — while retaining long-term memory of distant key information (paths, decisions, signatures). You can work in the **same session for months** without outgrowing the context.
+2. **Context stays lean over the long run.** In practice context typically holds under ~150K tokens (opencode-acp keeps it under ~200K), so compared to traditional compaction that lets context balloon toward 1M, **a single session costs roughly 5× less in tokens**.
 
 ## Install
 
 ```bash
-pi install pai-acp
+pi install npm:pai-acp
 ```
 
-Once renamed:
+That's it. The extension auto-loads on next Pi startup. No configuration needed — it reads your model's context window automatically.
+
+> **Uninstall `pi-subagents` first (optional, recommended).** pai-acp ships its own `acp_delegate` sub-agent tool (see below) that replaces pi-subagents at a fraction of the context cost (~600 tok vs ~7K tok/turn). If you have pi-subagents installed, remove it to avoid duplicate delegation tools:
+> ```bash
+> pi remove npm:pi-subagents
+> ```
+
+## How it works
+
+ACP intercepts Pi's `context` event (fired before each LLM call) and runs an 8-stage pipeline:
 
-```bash
-pi install billion-context-pi
 ```
+assign refs → sync blocks → prune → filter → hide calls → recommend → nudge → emergency truncate
+```
+
+Each message gets an invisible `<acp>` ref tag (`m00001`, `m00002`, ...) visible to the model but not the user. The model uses these refs to specify compression ranges.
+
+Pi's built-in auto-compaction is cancelled — ACP is the sole context manager.
+
+## Model-facing tools
+
+| Tool | What it does |
+|------|-------------|
+| `compress` | Replace a contiguous message range with a detailed summary |
+| `decompress` | Restore a previously compressed block's content |
+| `search_context` | Search compressed block summaries (and visible messages) by keyword |
+| `acp_status` | Show context usage, compressed blocks, compressible ranges |
+| `acp_delegate` | Spawn a clean-context sub-agent for a task (review / research / implement / plan / advise) |
+| `acp_delegate_wait` | Block until a delegate run finishes (returns its result; times out otherwise) |
+| `acp_delegate_cancel` | Cancel a running delegate by runId |
+
+### acp_delegate — clean-context delegation
+
+Hand a self-contained task to a fresh pi process running in a clean context. Five built-in roles, each with a tailored tool whitelist and system prompt:
+
+| Role | Tools | Best for |
+|------|-------|----------|
+| `reviewer` | read, bash | Read-only code review (bugs, risks, file:line) |
+| `researcher` | read, bash | Read-only codebase investigation |
+| `worker` | read, edit, write, bash | Make code changes |
+| `planner` | read, bash | Analyze + propose a step-by-step plan |
+| `oracle` | read, bash | Answer questions / advise |
+
+The full delegate result is saved to a file (`/tmp/acp-delegate/<runId>.out`); the tool result and injected notification carry only the **task title + file path** (no preview) — use `read` for the details. This keeps the parent context lean.
+
+- **Interactive (TUI) & RPC modes**: `async:true` (default) runs the child in the background; a short completion notification is injected into the chat when it finishes.
+- **Print / JSON modes** (`pi -p`, SDK): `async:true` auto-downgrades to **synchronous** — the result returns as the tool result in the same turn (the parent exits after one turn, so background injection would be lost).
+
+In the **interactive TUI**, async runs also show a live status widget below the editor (agent, elapsed seconds, task preview), so you always know what's running and for how long. Disabled automatically in RPC/print/JSON.
+
+## `/acp` command
+
+Rich status display for the user:
+
+```
+╭─────────────────────────────────────────────╮
+│           ACP Context Analysis              │
+╰─────────────────────────────────────────────╯
+ pai-acp@0.1.14
+
+Context: 12% (120K / 1.0M)
+Growth: +15K since last nudge
+
+Token Breakdown:
+  System     ░░░░░░░░░░░░░░░░░░░░   2%  2.1K
+  Tool       ████████████░░░░░░░░  58%  69.6K
+  Summaries  ████░░░░░░░░░░░░░░░░  20%  24.0K
+  Code       ██░░░░░░░░░░░░░░░░░░  10%  12.0K
+  Text       █░░░░░░░░░░░░░░░░░░░   5%  6.0K
+
+Blocks: 3 active (3.7K summary, 15.2K original compressed)
+  b1 (T1)  3.7K→599  age=5m  "API exploration"
+  b2 (T1)  8.2K→2.1K  age=2m  "Debug session"
+  b3 (T2)  3.3K→1.0K  age=1m  "Architecture review"
+```
+
+## Configuration
+
+pai-acp works out of the box with no configuration. Three optional keys can be set in a JSON config file.
+
+### Config file
+
+Create `~/.pi/acp.json` (global) and/or `<project>/.pi/acp.json` (project-local, overrides global):
+
+```json
+{
+  "debug": false,
+  "autoUpdate": true,
+  "modelContextLimit": 200000,
+  "delegate": true
+}
+```
+
+| Key | Default | Description |
+|-----|---------|-------------|
+| `debug` | `false` | Write diagnostic events to `~/.pi/acp-debug.log`. Also enabled by env `ACP_DEBUG=1`. |
+| `autoUpdate` | `true` | On Pi startup, check npm for a newer version and auto-install it (throttled to one check per 3 minutes). Disable to avoid all startup network calls. |
+| `modelContextLimit` | *(auto)* | Override the context limit (in tokens). Defaults to the model's `contextWindow`. |
+| `delegate` | `true` | Enable the `acp_delegate` tools (delegate/wait/cancel) and their system-prompt section. Set `false` to skip registering them (e.g. you use a different sub-agent extension, or run headless where async injection adds no value). |
+
+> **Only these four keys are read from `acp.json`.** Other tuning knobs (`preserveRecentMessages`, `protectedTools`, nudge thresholds) are code-level and not user-overridable.
+
+### Environment variables
+
+| Variable | Effect |
+|----------|--------|
+| `ACP_AUTO_UPDATE` | Set to `0` / `false` / `no` / `off` (case-insensitive) to disable auto-update, overriding the config. |
+| `ACP_MODEL_CONTEXT_LIMIT` | Override the context limit. Takes precedence over the config value. |
+| `ACP_DEBUG` | Set to `1` or `true` to enable debug logging. |
+
+### Compression philosophy
+
+The model receives detailed guidance (in its system prompt) on **when** to compress, **what** to keep verbatim (paths, signatures, errors, decisions, user intent), and **what** to drop (verbose logs, duplicates, consumed exploration). This guidance is injected on every turn so it stays in the model's attention.
+
+### What gets protected
+
+ACP protects three categories of content from compression:
+
+1. **Always-protected tools** — `compress` calls are hard-protected (they're load-bearing metadata; compressing them breaks decompress and the "summary is historical" contract).
+2. **Soft recent-zone** — the last N messages (default 5) and last ~5K tokens are soft-protected so the model keeps its working set. Tool results from `decompress`, `search_context`, `read`, and `bash` are **excluded** from this zone: they're large and meant to be compressible once consumed, so they don't eat the protected budget.
+3. **Last user message** — always protected (user intent must survive).
 
-## Related
+## Built on acp-kernel
 
-- [`billion-context`](https://www.npmjs.com/package/billion-context) — platform-agnostic core (reserved).
-- [`billion-context-opencode`](https://www.npmjs.com/package/billion-context-opencode) — opencode adapter (reserved).
+The compression engine is [`acp-kernel`](https://github.com/ranxianglei/acp-kernel) — a platform-agnostic, MIT-licensed library with 208 tests. It's bundled inline into `dist/index.js`, so there are zero runtime dependencies.
 
 ## License
 
-MIT
+MIT.

package/README.zh-CN.md

@@ -0,0 +1,173 @@
+[English](./README.md) | [中文](./README.zh-CN.md)
+
+<p align="center">
+<strong>主动上下文剪枝</strong> — <a href="https://pi.dev">Pi</a> 的 ACP 插件
+<br />
+由模型决定<em>何时</em>压缩、压缩<em>什么</em> — 而非硬性截断。
+</p>
+
+---
+
+<p align="center">
+<a href="https://www.npmjs.com/package/pai-acp"><img src="https://img.shields.io/npm/v/pai-acp.svg?style=flat-square" alt="npm"></a>
+<a href="https://github.com/ranxianglei/pai-acp/blob/master/LICENSE"><img src="https://img.shields.io/npm/l/pai-acp.svg?style=flat-square" alt="license"></a>
+<a href="https://github.com/ranxianglei/pai-acp"><img src="https://img.shields.io/badge/GitHub-ranxianglei%2Fpai--acp-181717?style=flat-square&logo=github" alt="GitHub"></a>
+</p>
+
+<p align="center">
+<code>pi install npm:pai-acp</code>
+</p>
+
+---
+
+## 为什么选择 ACP
+
+当对话变长,模型的上下文会耗尽。多数工具采用硬截断 —— 静默丢弃早期消息。**ACP** 把 `compress` 工具交给模型:由 LLM 决定**何时**压缩、压缩**什么**,将内容压缩成高保真摘要,在回收上下文空间的同时保留关键细节(文件路径、决策、错误字符串)。
+
+与 Pi 内置的自动压缩(把所有内容替换成单个摘要)不同,ACP:
+
+- **保留结构** — 压缩的范围变成带标签的块,可后续解压
+- **多级压缩** — 摘要可被进一步蒸馏(T1 → T2 → T3),随会话增长保持有界
+- **可搜索** — `search_context` 无需解压即可搜索已压缩块内的信息
+- **有选择性** — 受保护的工具、用户消息、近期工作集永不被压缩
+
+这使得:
+
+1. **一个会话即可支撑海量工作。** 根据三级压缩架构的模拟测试(见 [opencode-acp](https://github.com/ranxianglei/opencode-acp)),单会话累计可处理约 100 亿至 600 亿 token —— 同时对遥远的关键信息(路径、决策、签名)保持长久记忆。用户可以在**同一个会话里连续工作几个月**,而无需因为上下文膨胀而开新会话丢上下文。
+2. **上下文长期保持精简。** 实际运行中上下文通常稳定在 15 万 token 以下(opencode-acp 实测维持在 20 万以下),相比传统压缩方案动辄撑到 100 万上下文,**单会话累计可节省近 5 倍的 token 费用**。
+
+## 安装
+
+```bash
+pi install npm:pai-acp
+```
+
+完成。扩展在下次 Pi 启动时自动加载。无需配置 —— 它会自动读取模型的上下文窗口。
+
+> **建议先卸载 `pi-subagents`(可选,推荐)。** pai-acp 自带 `acp_delegate` 子代理工具(见下文),以极低的上下文成本(~600 tok vs ~7K tok/轮)替代 pi-subagents。如果你已安装 pi-subagents,卸载它以避免重复的委派工具:
+> ```bash
+> pi remove npm:pi-subagents
+> ```
+
+## 工作原理
+
+ACP 拦截 Pi 的 `context` 事件(每次 LLM 调用前触发),运行一个 8 阶段管线:
+
+```
+assign refs → sync blocks → prune → filter → hide calls → recommend → nudge → emergency truncate
+```
+
+每条消息获得一个不可见的 `<acp>` 引用标签(`m00001`、`m00002`、...),对模型可见但用户不可见。模型用这些引用来指定压缩范围。
+
+Pi 内置的自动压缩会被取消 —— ACP 是唯一的上下文管理者。
+
+## 模型工具
+
+| 工具 | 作用 |
+|------|------|
+| `compress` | 用详细摘要替换连续的消息范围 |
+| `decompress` | 恢复之前压缩的块内容 |
+| `search_context` | 按关键词搜索已压缩块摘要(及可见消息) |
+| `acp_status` | 显示上下文用量、已压缩块、可压缩范围 |
+| `acp_delegate` | 为某个任务派生一个干净上下文的子代理(审查 / 调研 / 实现 / 规划 / 建议) |
+| `acp_delegate_wait` | 阻塞等待委派任务完成(返回结果,否则超时) |
+| `acp_delegate_cancel` | 按 runId 取消正在运行的委派任务 |
+
+### acp_delegate — 干净上下文委派
+
+把一个自包含的任务交给一个运行在干净上下文中的新 pi 进程。五个内置角色,各自有定制的工具白名单和系统提示:
+
+| 角色 | 工具 | 适用场景 |
+|------|------|----------|
+| `reviewer` | read, bash | 只读代码审查(bug、风险、file:line) |
+| `researcher` | read, bash | 只读代码库调研 |
+| `worker` | read, edit, write, bash | 修改代码 |
+| `planner` | read, bash | 分析 + 提出分步计划 |
+| `oracle` | read, bash | 回答问题 / 建议 |
+
+委派的完整结果保存到文件(`/tmp/acp-delegate/<runId>.out`);工具结果和注入通知只携带**任务标题 + 文件路径**(无预览)— 需要细节时用 `read` 读取。这让父上下文保持精简。
+
+- **交互(TUI)与 RPC 模式**:`async:true`(默认)在后台运行子进程;完成时一条简短通知注入到聊天框。
+- **Print / JSON 模式**(`pi -p`、SDK):`async:true` 自动降级为**同步** — 结果在同一轮作为工具结果返回(父进程一轮后即退出,后台注入会丢失)。
+
+在**交互 TUI** 中,异步运行还会在编辑器下方显示一个实时状态 widget(角色、已运行秒数、任务预览),让你随时知道什么在跑、跑了多久。RPC/print/JSON 模式自动禁用。
+
+## `/acp` 命令
+
+为用户提供丰富的状态显示:
+
+```
+╭─────────────────────────────────────────────╮
+│           ACP Context Analysis              │
+╰─────────────────────────────────────────────╯
+ pai-acp@0.1.14
+
+Context: 12% (120K / 1.0M)
+Growth: +15K since last nudge
+
+Token Breakdown:
+  System     ░░░░░░░░░░░░░░░░░░░░   2%  2.1K
+  Tool       ████████████░░░░░░░░  58%  69.6K
+  Summaries  ████░░░░░░░░░░░░░░░░  20%  24.0K
+  Code       ██░░░░░░░░░░░░░░░░░░  10%  12.0K
+  Text       █░░░░░░░░░░░░░░░░░░░   5%  6.0K
+
+Blocks: 3 active (3.7K summary, 15.2K original compressed)
+  b1 (T1)  3.7K→599  age=5m  "API exploration"
+  b2 (T1)  8.2K→2.1K  age=2m  "Debug session"
+  b3 (T2)  3.3K→1.0K  age=1m  "Architecture review"
+```
+
+## 配置
+
+pai-acp 开箱即用,无需任何配置。可以在 JSON 配置文件中设置三个可选 key。
+
+### 配置文件
+
+创建 `~/.pi/acp.json`(全局)和/或 `<项目>/.pi/acp.json`(项目级,覆盖全局):
+
+```json
+{
+  "debug": false,
+  "autoUpdate": true,
+  "modelContextLimit": 200000,
+  "delegate": true
+}
+```
+
+| Key | 默认值 | 说明 |
+|-----|--------|------|
+| `debug` | `false` | 将诊断事件写入 `~/.pi/acp-debug.log`。也可用环境变量 `ACP_DEBUG=1` 启用。 |
+| `autoUpdate` | `true` | Pi 启动时检查 npm 是否有更新版本并自动安装(限频:每 3 分钟最多一次检查)。禁用以避免所有启动时的网络请求。 |
+| `modelContextLimit` | *(自动)* | 覆盖上下文上限(token 数)。默认为模型的 `contextWindow`。 |
+| `delegate` | `true` | 启用 `acp_delegate` 工具(delegate/wait/cancel)及其系统提示词段落。设为 `false` 则不注册这些工具(例如你用了别的子代理扩展,或跑 headless 场景异步注入没有意义)。 |
+
+> **只有这四个 key 会被 `acp.json` 读取。** 其他调优参数(`preserveRecentMessages`、`protectedTools`、nudge 阈值)是代码级的,不向用户开放。
+
+### 环境变量
+
+| 变量 | 作用 |
+|------|------|
+| `ACP_AUTO_UPDATE` | 设为 `0` / `false` / `no` / `off`(不区分大小写)以禁用自动更新,覆盖配置值。 |
+| `ACP_MODEL_CONTEXT_LIMIT` | 覆盖上下文上限。优先级高于配置值。 |
+| `ACP_DEBUG` | 设为 `1` 或 `true` 启用 debug 日志。 |
+
+### 压缩策略
+
+模型接收(在其系统提示中)关于**何时**压缩、**逐字保留什么**(路径、签名、错误、决策、用户意图)、**丢弃什么**(冗长日志、重复内容、已消费的探索)的详细指导。这段指导每轮都注入,确保它始终在模型的注意力范围内。
+
+### 哪些内容会被保护
+
+ACP 保护三类内容不被压缩:
+
+1. **永久保护的工具** — `compress` 调用被硬保护(它们是承载关键元数据的;压缩它们会破坏 decompress 和"摘要是历史"的契约)。
+2. **软近期区** — 最后 N 条消息(默认 5)和最后约 5K token 被软保护,让模型保留工作集。来自 `decompress`、`search_context`、`read`、`bash` 的工具结果被**排除**出此区:它们体量大、消费后就该能压缩,所以不该占用保护预算。
+3. **最后一条用户消息** — 始终保护(用户意图必须存活)。
+
+## 基于 acp-kernel
+
+压缩引擎是 [`acp-kernel`](https://github.com/ranxianglei/acp-kernel) — 平台无关、MIT 许可的库,有 208 个测试。它被内联打包进 `dist/index.js`,因此零运行时依赖。
+
+## 许可证
+
+MIT.

package/dist/commands.d.ts

@@ -0,0 +1,8 @@
+import type { RegisteredCommand } from "@earendil-works/pi-coding-agent";
+import type { AcpRuntime } from "./runtime.js";
+type CommandOptions = Omit<RegisteredCommand, "name" | "sourceInfo">;
+export declare function makeCommands(runtime: AcpRuntime): Array<{
+    name: string;
+    options: CommandOptions;
+}>;
+export {};

package/dist/compress-tool.d.ts

@@ -0,0 +1,15 @@
+import { Type } from "typebox";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { AcpRuntime } from "./runtime.js";
+declare const CompressParams: Type.TObject<{
+    topic: Type.TOptional<Type.TString>;
+    content: Type.TArray<Type.TObject<{
+        startId: Type.TString;
+        endId: Type.TString;
+        summary: Type.TString;
+        topic: Type.TOptional<Type.TString>;
+    }>>;
+    summaryMaxChars: Type.TOptional<Type.TNumber>;
+}>;
+export declare function makeCompressTool(runtime: AcpRuntime): ToolDefinition<typeof CompressParams>;
+export {};

package/dist/config.d.ts

@@ -0,0 +1,25 @@
+import { type Config } from "acp-kernel";
+/**
+ * Adapter configuration. Maps onto acp-kernel's `Config` plus Pi-specific knobs
+ * (live model context window, protected tools, state persistence).
+ */
+export interface AdapterConfig {
+    /** When omitted, the adapter reads `ctx.model.contextWindow` live each turn.
+     *  Set explicitly for tests/headless runs. */
+    modelContextLimit?: number;
+    protectedTools?: string[];
+    preserveRecentMessages?: number;
+    /** Check npm for a newer pai-acp on startup and auto-install it. Default: true.
+     *  Disable via `autoUpdate: false` or env `ACP_AUTO_UPDATE=0` to avoid all
+     *  network calls on startup. */
+    autoUpdate?: boolean;
+    /** Write ACP debug events to the debug log file (default ~/.pi/acp-debug.log).
+     *  Default: false (or env ACP_DEBUG=1/true). */
+    debug?: boolean;
+    /** Enable acp_delegate tools (delegate/wait/cancel) and their system-prompt
+     *  section. Default: true. Set `delegate: false` (adapter config or
+     *  ~/.pi/acp.json) to skip registering them. */
+    delegate?: boolean;
+    coreOverrides?: Partial<Config>;
+}
+export declare function resolveConfig(adapter: AdapterConfig, liveContextLimit: number): Config;

package/dist/decompress-tool.d.ts

@@ -0,0 +1,11 @@
+import { Type } from "typebox";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { AcpRuntime } from "./runtime.js";
+declare const DecompressParams: Type.TObject<{
+    blockId: Type.TString;
+    full: Type.TOptional<Type.TBoolean>;
+    toFile: Type.TOptional<Type.TString>;
+    inline: Type.TOptional<Type.TBoolean>;
+}>;
+export declare function makeDecompressTool(runtime: AcpRuntime): ToolDefinition<typeof DecompressParams>;
+export {};

package/dist/delegate-tool.d.ts

@@ -0,0 +1,27 @@
+import { Type } from "typebox";
+import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
+/** Snapshot of currently-running delegate runs, for the TUI status widget. */
+export declare function runningRunsSnapshot(): {
+    runId: string;
+    agent: string;
+    task: string;
+    startedAt: number;
+}[];
+declare const DelegateParams: Type.TObject<{
+    agent: Type.TString;
+    task: Type.TString;
+    cwd: Type.TOptional<Type.TString>;
+    model: Type.TOptional<Type.TString>;
+    async: Type.TOptional<Type.TBoolean>;
+}>;
+declare const CancelParams: Type.TObject<{
+    runId: Type.TString;
+}>;
+declare const WaitParams: Type.TObject<{
+    runId: Type.TString;
+    timeout: Type.TOptional<Type.TInteger>;
+}>;
+export declare function makeDelegateTool(pi: ExtensionAPI): ToolDefinition<typeof DelegateParams>;
+export declare function makeDelegateWaitTool(_pi: ExtensionAPI): ToolDefinition<typeof WaitParams>;
+export declare function makeDelegateCancelTool(_pi: ExtensionAPI): ToolDefinition<typeof CancelParams>;
+export {};

package/dist/fleet-widget.d.ts

@@ -0,0 +1,14 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+interface WidgetRun {
+    runId: string;
+    agent: string;
+    task: string;
+    startedAt: number;
+}
+type RunsSnapshot = () => WidgetRun[];
+export declare const delegateStatusWidget: {
+    setContext(ctx: ExtensionContext, snapshot: RunsSnapshot): void;
+    dispose(): void;
+    poke(): void;
+};
+export {};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
+import type { AdapterConfig } from "./config.js";
+export declare function createAcpExtension(adapter?: AdapterConfig): ExtensionFactory;
+declare const _default: ExtensionFactory;
+export default _default;