@ia-ccun/code-agent-cli 0.0.52-beta.3 → 0.0.52-beta.4

package/config/agent/skills/ponytail-review/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: ponytail-review
+description: >
+  Code review focused exclusively on over-engineering. Finds what to delete:
+  reinvented standard library, unneeded dependencies, speculative abstractions,
+  dead flexibility. One line per finding: location, what to cut, what replaces
+  it. Use when the user says "review for over-engineering", "what can we
+  delete", "is this over-engineered", "simplify review", or invokes
+  /ponytail-review. Complements correctness-focused review, this one only
+  hunts complexity.
+---
+
+Review diffs for unnecessary complexity. One line per finding: location, what
+to cut, what replaces it. The diff's best outcome is getting shorter.
+
+## Format
+
+`L<line>: <tag> <what>. <replacement>.`, or `<file>:L<line>: ...` for
+multi-file diffs.
+
+Tags:
+
+- `delete:` dead code, unused flexibility, speculative feature. Replacement: nothing.
+- `stdlib:` hand-rolled thing the standard library ships. Name the function.
+- `native:` dependency or code doing what the platform already does. Name the feature.
+- `yagni:` abstraction with one implementation, config nobody sets, layer with one caller.
+- `shrink:` same logic, fewer lines. Show the shorter form.
+
+## Examples
+
+❌ "This EmailValidator class might be more complex than necessary, have you
+considered whether all these validation rules are needed at this stage?"
+
+✅ `L12-38: stdlib: 27-line validator class. "@" in email, 1 line, real validation is the confirmation mail.`
+
+✅ `L4: native: moment.js imported for one format call. Intl.DateTimeFormat, 0 deps.`
+
+✅ `repo.py:L88: yagni: AbstractRepository with one implementation. Inline it until a second one exists.`
+
+✅ `L52-71: delete: retry wrapper around an idempotent local call. Nothing replaces it.`
+
+✅ `L30-44: shrink: manual loop builds dict. dict(zip(keys, values)), 1 line.`
+
+## Scoring
+
+End with the only metric that matters: `net: -<N> lines possible.`
+
+If there is nothing to cut, say `Lean already. Ship.` and stop.
+
+## Boundaries
+
+Complexity only, correctness bugs, security holes, and performance go to a
+normal review pass, not this one. A single smoke test or `assert`-based
+self-check is the ponytail minimum, not bloat, never flag it for deletion.
+Does not apply the fixes, only lists them.
+"stop ponytail-review" or "normal mode": revert to verbose review style.

package/config/agent/skills/zread/README.md

@@ -0,0 +1,115 @@
+# Zread Skill
+
+This repository contains a skill for `zread`, a CLI that generates wiki-style
+documentation for code repositories.
+
+The skill is meant for one job: help an agent understand an unfamiliar codebase
+through `zread` output instead of re-reading the entire repository file by file.
+
+## Installation
+
+### 1. Install the zread CLI
+
+Install `zread` first. There are two supported installation methods:
+
+```bash
+npm install -g zread_cli
+```
+
+or
+
+```bash
+brew tap ZreadAI/homebrew-tap
+brew install zread
+```
+
+Then verify the installation:
+
+```bash
+zread version
+```
+
+### 2. Install this skill
+
+Ask your AI agent to install the skill from GitHub:
+
+```text
+install this skill https://github.com/ZreadAI/zread-skill
+```
+
+If you prefer to install it manually, copy this directory into your local
+skills directory:
+
+| Agent       | Skills directory        |
+| ----------- | ----------------------- |
+| Claude Code | `~/.claude/skills/`   |
+| OpenClaw    | `~/.openclaw/skills/` |
+| Codex       | `~/.agents/skills/`   |
+
+Example:
+
+```bash
+cp -R zread ~/.claude/skills/zread
+```
+
+Your final layout should look like this:
+
+```text
+<skills-dir>/zread/
+  SKILL.md
+  README.md
+  references/
+    stdio-protocol.md
+```
+
+Once the folder is in place, an agent that supports `SKILL.md`-based skills can
+load and use it.
+
+## Features
+
+- Read existing `./.zread/wiki/` output instead of crawling source files again
+- Guide an agent to run `zread generate` safely when documentation does not
+  exist yet
+- Use `--stdio` as the default mode for agent automation, instead of parsing
+  the interactive TUI
+- Explain the role of `current`, `versions`, and `drafts` in zread output
+- Include a reference for the `zread --stdio` JSON-line protocol
+
+## When To Use
+
+Use this skill when you want to:
+
+- understand an unfamiliar repository quickly
+- read an existing zread-generated wiki
+- generate a repository overview or project wiki
+- serve docs locally with `zread browse`
+- drive `zread` programmatically from a script or agent
+
+## How It Works
+
+The skill follows a simple workflow:
+
+1. If `./.zread/wiki/current` exists, read the generated wiki files directly.
+2. If no wiki exists, run `zread generate` only when the user wants docs to be
+   generated.
+3. Before generation, confirm with the user because generation consumes LLM
+   tokens and writes under `./.zread/`.
+4. In automated workflows, use `--stdio`.
+
+## Repository Layout
+
+- `SKILL.md`: the skill definition, trigger conditions, and operating rules
+- `references/stdio-protocol.md`: the `zread --stdio` machine protocol
+- `appmap.log`: local artifact, not part of the skill itself
+
+## zread Output
+
+After a successful generation, zread typically writes:
+
+- `./.zread/wiki/current`: the active wiki version id
+- `./.zread/wiki/versions/<id>/wiki.json`: the generated page index
+- `./.zread/wiki/versions/<id>/<file>`: the actual markdown pages
+- `./.zread/wiki/drafts/`: unfinished generation state
+
+If you need to integrate with `zread` programmatically, see
+[references/stdio-protocol.md](./references/stdio-protocol.md).

package/config/agent/skills/zread/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: zread
+description: Produce and consume a wiki-style knowledge base for a code repository via the `zread` CLI and its on-disk output under `./.zread/wiki/`. Use this skill whenever the user wants to understand, onboard onto, explore, summarize, map, or get an overview of an unfamiliar codebase; asks for architecture docs, a project wiki, a repo walkthrough, module/package explanations, or "what does this repo do"; wants to generate, regenerate, resume, browse, or serve code documentation locally; or mentions zread / zread.ai directly. Also use it proactively before diving into a large unknown repo — if `./.zread/wiki/current` exists, read the generated pages instead of crawling source file-by-file; if it doesn't, consider offering to run `zread generate`. The trigger is the intent (understand a codebase through generated docs), not the literal word "zread".
+---
+
+# zread skill
+
+`zread` is a CLI that generates wiki documentation from code in the current
+workspace using an LLM. Output lives under `./.zread/wiki/` in the workspace;
+public repos can also be viewed at https://zread.ai.
+
+This skill is intended for agent use. Read generated files directly from disk,
+and use `--stdio` as the default mode for any zread command instead of trying
+to parse the human TUI.
+
+## On-disk layout (read these directly)
+
+Always run `zread` from the workspace root. After a successful generation:
+
+- `./.zread/wiki/current` — text file containing the active version id
+  (e.g. `2026-03-12-010203`).
+- `./.zread/wiki/versions/<id>/wiki.json` — TOC: `{id, generated_at, language,
+  pages: [{slug, title, file, section, group, level}]}`.
+- `./.zread/wiki/versions/<id>/<file>` — page markdown referenced by `pages[*].file`.
+- `./.zread/wiki/drafts/` — in-progress generation; presence means a previous
+  run did not finish. `drafts/wiki.json` exists once the catalog phase
+  completed.
+- `~/.zread/config.yaml` — global config (LLM provider, language, concurrency).
+- `~/.zread/login.json` — presence indicates the user has logged in.
+
+To answer questions about a codebase that already has zread output, read these
+files directly with the file tools — do not invoke `zread browse`.
+
+## Commands
+
+| Command | Purpose | Key flags |
+|---|---|---|
+| `zread generate` | Generate wiki for cwd | `-y/--yes`, `--draft resume\|clear\|cancel`, `--skip-failed`, `--stdio` |
+| `zread browse` | Serve docs at http://localhost:9681+ and open browser | `--generate`, `--version <id>`, `--host`, `--port`, `--stdio` |
+| `zread login` | OAuth into BigModel/Z.AI to obtain an API key | `--custom`, `--model`, `--stdio` |
+| `zread config` | Edit `~/.zread/config.yaml` | `--stdio` |
+| `zread update` | Self-update CLI | `--stdio` |
+| `zread version` | Print version | `--stdio` |
+
+`--stdio` is supported on every command and turns the process into a JSON-line
+machine protocol on stdin/stdout. See
+[references/stdio-protocol.md](./references/stdio-protocol.md) for the wire
+format (events, `waiting_for`, `done`, `quit`). Load it whenever zread is
+invoked from another program/agent.
+
+## Decision tree for an AI agent
+
+1. **User wants to read existing wiki content?**
+   - Check `./.zread/wiki/current`. If present, read `wiki.json` and the page
+     markdown directly. No CLI invocation needed.
+   - For known *public* GitHub repos, prefer the `mcp__zread__*` tools
+     (`get_repo_structure`, `read_file`, `search_doc`) over running the CLI.
+
+2. **User wants to (re)generate docs?**
+   - Confirm with the user first — `generate` is long-running, calls an LLM,
+     and writes files. Get explicit consent in unfamiliar directories.
+   - Verify `~/.zread/login.json` exists or `~/.zread/config.yaml` has an
+     `llm.api_key`. If neither, run `zread login` first.
+   - If `./.zread/wiki/drafts/` exists, decide:
+     - resume previous run → `zread generate --draft resume -y`
+     - throw away and start fresh → `zread generate --draft clear -y`
+   - Otherwise: `zread generate -y`.
+   - To not block on a few failing pages: add `--skip-failed`.
+
+3. **User wants to view docs in a browser?**
+   - `zread browse` (add `--generate` to bootstrap if no wiki exists yet).
+
+4. **User wants to script zread / consume output programmatically?**
+   - Use `--stdio` and follow stdio-protocol.md. Do not screen-scrape the TUI.
+
+## Non-interactive invocation rules
+
+- Always pass `-y` to `generate` when running unattended; otherwise it stops
+  at a catalog confirmation gate.
+- Always set `--draft` explicitly when a draft may exist, so the command does
+  not prompt.
+- For any command run from another agent/script, use `--stdio` so output is
+  parseable JSON instead of ANSI TUI frames.
+- `zread` writes logs to `~/.zread/log/zread.log` — read this if a run fails
+  silently.
+
+## Safety / blast radius
+
+- `generate` consumes LLM tokens (real cost) and can run for many minutes on
+  large repos. Confirm before launching.
+- `generate` writes only under `./.zread/` and does not commit anything to
+  git. It is safe to delete `./.zread/wiki/drafts/` to recover from a stuck
+  state.
+- `update` replaces the zread binary in place and is hard to reverse — only
+  run it when the user explicitly asks.
+- `login` opens a browser for OAuth; do not run it in a non-interactive
+  context unless the user has asked for it.
+
+## Reference files
+
+- [references/stdio-protocol.md](./references/stdio-protocol.md) — JSON-line
+  wire protocol shared by every command's `--stdio` mode. Load when
+  programmatically driving zread.

package/config/agent/skills/zread/references/stdio-protocol.md

@@ -0,0 +1,312 @@
+# zread `--stdio` protocol
+
+Every zread command accepts `--stdio`, switching the process from an interactive
+TUI into a JSON-line machine protocol on stdin/stdout. This is the contract used
+by GUI / programmatic clients to drive zread.
+
+## Architecture
+
+zread internally uses a Driver / Client split:
+
+- **Driver** holds all business logic (loading config, calling LLMs, running the
+  doc server, managing drafts). It is framework-agnostic and only talks to a
+  `Transport`.
+- **Client** is either a Bubbletea TUI or `StdioClient`. With `--stdio`, the
+  cobra command instantiates `transport.NewLocalTransport()` (a channel pair),
+  spawns the driver in a goroutine, then runs `StdioClient.Run(ctx)`.
+- `StdioClient` reads JSON lines from `os.Stdin` and forwards them as commands
+  to the driver, while encoding `Event`s from the driver to `os.Stdout` (one
+  JSON object per line). It returns when an event with `"done": true` is
+  received.
+
+Result: stdin = command stream, stdout = event stream, both newline-delimited
+JSON. stderr is reserved for logs/errors and should not be parsed.
+
+## Event format (driver → client, stdout)
+
+```json
+{
+  "vm": { ... },
+  "waiting_for": ["..."],
+  "done": false,
+  "error": ""
+}
+```
+
+- `vm`: full ViewModel snapshot for the current state (shape varies per command — see below).
+- `waiting_for`: command `type` values the client may legally send right now. `quit` is always accepted regardless.
+- `done`: `true` on the final event; the process will exit on its own.
+- `error`: non-empty when the previous command was rejected; `vm`/`waiting_for` remain unchanged.
+
+Rules:
+- An event is emitted after every state transition. Treat `vm` as the full current state (no diffs).
+- `waiting_for: []` with `done: false` means the driver is awaiting an internal async result — do not send any command; just keep reading.
+- The very last event always has `done: true` and an empty `waiting_for`.
+
+## Command format (client → driver, stdin)
+
+One JSON object per line:
+
+```json
+{"type": "<command_type>", "params": { ... }}
+```
+
+- `type` is required. `params` may be omitted (treated as `{}`).
+- Universal command: `{"type":"quit","params":{}}` — every driver handles it and shuts down cleanly.
+- Command types prefixed with `_` are driver-internal. They never appear in `waiting_for`; clients must not send them.
+- Sending a command not in `waiting_for` returns an event with `error` set while `vm`/`waiting_for` remain unchanged.
+- Error message format: `"command \"xxx\" not allowed in state yyy"` / `"invalid params: ..."` / `"invalid JSON: ..."`.
+
+## Driving a session
+
+1. Spawn `zread <command> --stdio` with piped stdin/stdout.
+2. Read the first event — it carries the initial ViewModel and `waiting_for`.
+3. Render or inspect `vm`; pick a legal command from `waiting_for` and write it as a single JSON line followed by `\n`.
+4. Loop: read next event, react, write next command.
+5. Stop when `done: true` arrives. The process will exit on its own. Sending `quit` at any time triggers the same shutdown.
+
+---
+
+## `zread browse --stdio`
+
+### ViewModel fields
+
+| Field | Type | Notes |
+|---|---|---|
+| `state` | string | `"loading"` `"serving"` `"select_version"` `"no_wiki"` `"error"` |
+| `url` | string | Local server URL; present when `state="serving"` |
+| `browser_opened` | bool | Whether the browser was auto-launched |
+| `has_current` | bool | Whether a "current" wiki version exists |
+| `versions` | array | Present when `state="select_version"` |
+| `versions[].id` | string | Wiki version ID |
+| `versions[].timestamp` | string | Version timestamp |
+| `versions[].is_current` | bool | Whether this is the current version |
+| `error` | string | Present when `state="error"` |
+
+### Commands
+
+| State | `waiting_for` | Command | Params |
+|---|---|---|---|
+| `select_version` | `["select_version","quit"]` | `select_version` | `{"wiki_id":"<id>"}` or `{"current":true}` |
+| `serving` | `["quit"]` | — | — |
+| `no_wiki` | `["quit"]` | — | — |
+| `loading` | `[]` | *(wait for internal event)* | — |
+| `error` | `[]` | — | — |
+
+### State machine
+
+```
+loading ──(server ok)──────────────────► serving
+loading ──(error)──────────────────────► error (terminal)
+select_version ──(select_version cmd)──► loading ──► serving
+no_wiki ───────────────────────────────► (terminal, done=true)
+```
+
+---
+
+## `zread generate --stdio`
+
+### ViewModel fields
+
+| Field | Type | Notes |
+|---|---|---|
+| `state` | string | `"select_action"` `"running"` `"done"` `"error"` |
+| `max_retries` | int | Configured max retries per page |
+| `select_action.scenario` | string | `"has_wiki"` `"has_draft"` `"empty"` |
+| `select_action.wiki_date` | string | Date of existing wiki (when `scenario="has_wiki"`) |
+| `select_action.draft_done` | int | Pages already done in draft |
+| `select_action.draft_total` | int | Total pages in draft |
+| `select_action.next_action` | string | Pre-suggested action: `"generate"` `"browse"` `""` |
+| `catalog.status` | string | `"idle"` `"running"` `"done"` `"resumed"` `"error"` |
+| `catalog.tool_name` | string | Currently-running LLM tool (if any) |
+| `catalog.error` | string | Catalog error message |
+| `catalog.auto_retry` | int | Auto-retry count so far |
+| `pages.tasks` | array | Per-page task list |
+| `pages.tasks[].id` | int | Task ID (used for `retry` command) |
+| `pages.tasks[].title` | string | Page title |
+| `pages.tasks[].slug` | string | Page slug |
+| `pages.tasks[].state` | string | `"pending"` `"running"` `"retry_pending"` `"done"` `"failed"` `"resumed"` |
+| `pages.tasks[].retry_count` | int | Retries attempted so far |
+| `pages.tasks[].max_retries` | int | Retry limit for this task |
+| `pages.tasks[].error` | string | Error message if failed |
+| `pages.done` | int | Completed page count |
+| `pages.total` | int | Total page count |
+| `pages.waiting_retry` | bool | `true` when driver is paused waiting for retry/skip decision |
+| `done_total` | int | Total pages done (in `state="done"`) |
+| `error` | string | Fatal error message |
+
+### Commands
+
+| State / condition | `waiting_for` | Command | Params |
+|---|---|---|---|
+| `select_action` | `["select_action","cancel","quit"]` | `select_action` | `{"action":"generate"}` or `"browse"` or `"resume"` or `"clear"` or `"cancel"` |
+| `running` (normal) | `["quit"]` | — | — |
+| `running` (catalog error) | `["quit","retry_catalog"]` | `retry_catalog` | `{}` |
+| `running` (pages waiting retry) | `["quit","retry","skip_all"]` | `retry` | `{"task_id":<int>}` |
+| `running` (pages waiting retry) | `["quit","retry","skip_all"]` | `skip_all` | `{}` |
+| `running` | `["quit","cancel"]` | `cancel` | `{}` |
+
+### CLI flags that affect stdio flow
+
+- `--yes` / `-y`: skips the `select_action` gate; generation starts immediately.
+- `--draft-action <resume|clear|cancel>`: pre-answers the draft prompt.
+- `--skip-failed`: equivalent to auto-sending `skip_all` when pages fail.
+
+### State machine
+
+```
+select_action ──(generate/resume)──► running ──(all done, no failures)──► done
+select_action ──(cancel/browse)────► done (immediate)
+running ──(pages failed)───────────► waiting_retry=true, accepts retry/skip_all
+running ──(cancel)─────────────────► done
+```
+
+---
+
+## `zread config --stdio`
+
+### ViewModel fields
+
+| Field | Type | Notes |
+|---|---|---|
+| `fields` | array (9 items) | Ordered config fields |
+| `fields[].title_key` | string | Display label key |
+| `fields[].json_key` | string | Key to use in `update_fields`; empty = read-only |
+| `fields[].initial` | string | Value at load time |
+| `fields[].value` | string | Current (possibly edited) value |
+| `dirty` | bool | `true` if any field differs from `initial` |
+| `saved` | bool | `true` after successful save |
+| `error` | string | Validation error |
+
+Field index → `json_key` mapping:
+
+| Index | `json_key` | Notes |
+|---|---|---|
+| 0 | `language` | generation language |
+| 1 | `doc_language` | doc language |
+| 2 | *(empty)* | read-only LLM provider display |
+| 3 | `max_concurrent` | int |
+| 4 | `max_retries` | int |
+| 5 | `llm_provider` | editable in stdio mode |
+| 6 | `llm_base_url` | editable in stdio mode |
+| 7 | `llm_model` | editable in stdio mode |
+| 8 | `llm_api_key` | editable in stdio mode |
+
+### Commands
+
+No state machine. Fixed `waiting_for`: `["update_fields","save","reload_llm","quit"]`.
+
+| Command | Params | Effect |
+|---|---|---|
+| `update_fields` | `{"fields":{"<json_key>": "<value>", ...}}` | Partial update; only listed keys change |
+| `save` | `{}` | Persists config and terminates (`done=true`) |
+| `reload_llm` | `{}` | Re-validates LLM provider settings |
+| `quit` | `{}` | Exits without saving |
+
+---
+
+## `zread login --stdio`
+
+### ViewModel fields
+
+| Field | Type | Notes |
+|---|---|---|
+| `state` | string | See states below |
+| `authorize_url` | string | OAuth URL to open; present in `open_browser` state |
+| `auth_timeout` | int | Nanoseconds until auth expires; present in `waiting` state |
+| `browser_warn` | string | Warning if browser launch failed |
+| `username` | string | Logged-in username; present in `done` state |
+| `avail_models` | array of string | Models to choose from; present in `select_model` state |
+| `selected_model` | string | Currently selected model |
+| `error` | string | Error message in `error` state |
+| `wants_llm_provider_editor` | bool | `true` (with `done=true`) when `--custom` flag was used |
+
+States: `"select_region"` → `"init_flow"` → `"open_browser"` → `"waiting"` → `"select_model"` → `"saving"` → `"done"` / `"error"`
+
+### Commands
+
+| State | `waiting_for` | Command | Params |
+|---|---|---|---|
+| `select_region` | `["select_region","quit"]` | `select_region` | `{"region":"<provider_key>"}` or `{"region":"__use_own_key__"}` |
+| `select_model` | `["select_model","quit"]` | `select_model` | `{"model":"<model_id>"}` |
+| all others | `[]` | *(wait for internal auth events)* | — |
+
+### Special cases
+
+- `--custom` flag: driver immediately emits `done: true` with `wants_llm_provider_editor: true`. Client should then launch `zread config --stdio` to configure a custom LLM provider.
+
+### State machine
+
+```
+select_region ──(cmd)──► init_flow ──► open_browser ──► waiting ──► select_model
+select_model ──(cmd)───► saving ──► done
+any ────────────────────────────────────────────────────────────────► error
+```
+
+---
+
+## `zread update --stdio`
+
+### ViewModel fields
+
+| Field | Type | Notes |
+|---|---|---|
+| `state` | string | See states below |
+| `current_version` | string | Installed version |
+| `latest_version` | string | Available version; present in `has_update`+ |
+| `download_url` | string | Asset URL for the update binary |
+| `package_manager` | string | e.g. `"brew"`; present in `package_manager` state |
+| `downloaded_bytes` | int | Bytes downloaded so far |
+| `total_bytes` | int | Total download size |
+| `download_percent` | float | 0–100 |
+| `error` | string | Error message in `error` state |
+
+States: `"checking"` → `"up_to_date"` / `"package_manager"` / `"has_update"` → `"downloading"` → `"confirm_restart"` / `"error"`
+
+Terminal states (emit `done=true`): `up_to_date`, `package_manager`, `error`, and after restart/skip.
+
+### Commands
+
+| State | `waiting_for` | Command | Params |
+|---|---|---|---|
+| `has_update` | `["download","quit"]` | `download` | `{}` |
+| `confirm_restart` | `["restart","skip_restart","quit"]` | `restart` | `{}` |
+| `confirm_restart` | `["restart","skip_restart","quit"]` | `skip_restart` | `{}` |
+| all others | `[]` | *(wait for internal events)* | — |
+
+### State machine
+
+```
+checking ──► up_to_date (terminal)
+         ──► package_manager (terminal)
+         ──► has_update ──(download)──► downloading ──► confirm_restart
+                                                     ──(restart/skip)──► done
+checking / downloading ──(error)──► error (terminal)
+```
+
+---
+
+## `zread version --stdio`
+
+Emits a single event with `done: true` immediately. No commands are accepted.
+
+### ViewModel fields
+
+| Field | Type | Notes |
+|---|---|---|
+| `version` | string | e.g. `"1.2.3"` |
+| `channel` | string | Release channel (if set) |
+| `go_version` | string | Go runtime version |
+| `os` | string | OS name |
+| `arch` | string | CPU architecture |
+
+---
+
+## Practical tips
+
+- Always flush stdin after writing a command (the driver reads line-by-line).
+- Treat any line on stdout that fails to parse as JSON as a bug — log it but do not crash; zread should not print non-JSON to stdout in `--stdio` mode.
+- When `waiting_for` is `[]` and `done` is `false`, keep reading — the driver is awaiting an internal async result and will emit the next event on its own.
+- For long-running commands (`generate`), keep reading events continuously; there is no heartbeat, but progress events arrive whenever state changes.
+- To cancel cleanly, send `{"type":"quit","params":{}}` and then drain events until `done` rather than killing the process.
+- `done: true` events are always terminal. Do not send further commands.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ia-ccun/code-agent-cli",
-  "version": "0.0.52-beta.3",
+  "version": "0.0.52-beta.4",
   "description": "AI Coding Agent CLI - 基于OpenClaw🦞底层Agent原理封装的编码智能体（供学习使用）。",
   "type": "module",
   "main": "./dist/index.js",
@@ -38,7 +38,8 @@
     "@earendil-works/pi-agent-core": "^0.77.0",
     "@earendil-works/pi-ai": "^0.77.0",
     "@earendil-works/pi-coding-agent": "^0.77.0",
-    "@earendil-works/pi-tui": "^0.77.0"
+    "@earendil-works/pi-tui": "^0.77.0",
+    "@firstpick/pi-utils": "^0.2.2"
   },
   "overrides": {
     "glob": "^11.0.0",
@@ -60,6 +61,7 @@
     "@typescript-eslint/parser": "^8.57.0",
     "eslint": "^10.0.3",
     "husky": "^9.1.7",
+    "pi-lean-ctx": "^3.8.11",
     "playwright": "^1.60.0",
     "shx": "^0.4.0",
     "typescript": "^5.7.2",

package/scripts/postinstall.js

@@ -241,7 +241,6 @@ const FORCE_OVERWRITE_LIST = [
   'APPEND_SYSTEM.md',
   'SYSTEM.md',
   'dangerous-patterns.json',
-  'settings.json',
   'help.md',
   'extensions/*.ts',
   'prompts/*.md',