Skip to content

pi-python v0.9.0

Choose a tag to compare

@github-actions github-actions released this 11 Nov 10:40
· 15 commits to main since this release
6e96066

This release is about Auto. permission = "auto" is a real permission mode now: it runs the calls that are clearly in scope and asks about the rest. The Python agent runs it, and zypi offers it. A bash command that no rule decides goes to a model by default. Changed has the changes that you can see: permission = "auto" no longer means "no question", Auto sends your messages and that command to a model, and zypi keeps pasted images in a new folder. Fixed has two security fixes for holes that v0.8.0 has (git status at the start of a session, and the isolation of the workflow tool), and a fix for new installs that got agent-client-protocol 1.0.0 and did not start. Removed has more dead code of the TUI. Known issues says what does not work yet and what nobody tried by hand.

Added

  • The README tells how to run zycode as a subagent of DeepSeek Harness (docs): the new section "In DeepSeek Harness (as a subagent)" has the install command for @deepseek-ai/dsh-subagent-acp and @deepseek-ai/dsh-tool-subagent (alpha), the two config rows, the permission behaviour, and a warning: permission: allow in the DSH row answers zycode's project-trust question with "Trust and remember", so keep reject and set default_project_trust = "never" in the [extensions] table of an isolated PI_HOME. Verified end to end with a real model (OpenRouter deepseek/deepseek-v4.1-flash: one read task, one write task with permission = "auto"; DSH main model and zycode child both real) and with a mock model for the wiring. It was run with DSH 0.2.2-alpha.2 (headless profile) and pi-agent-cli-lc 0.7.0 on Linux: install, spawn, handshake, the result in DSH's completion notice, cwd, read and write through a scripted tool call, a denied and an allowed permission request, SIGTERM and SIGKILL of dsh (the child's tool process is reaped), the first-run message, and the trust hazard and its mitigation. Not tried: the [deepseek] extra, a long real task, a cold uvx download, DSH Web/Desktop, Windows and macOS. No code changes.
  • The README tells how to run zycode as a full session in DeepSeek Harness through a community plugin (docs): the new section "In DeepSeek Harness (full session, community plugin)" covers the third-party plugin @zaimokuza/dsh-acp-adapter, with an unofficial notice (DeepSeek has not reviewed it, it does not list zycode as tested). It has the install commands, the agent row (command: uvx, an isolated PI_HOME, loginHint), and notes on key, first run, permissions, project trust, models, resume, cancel and the MCP notice. Verified end to end with a real model (OpenRouter deepseek/deepseek-v4.1-flash for DSH's main model and for zycode) in the DSH Web app on Linux, with DSH 0.2.1-rc.4, adapter 0.2.1-rc.4.1 (the newest adapter, pinned to exactly that DSH; the installer refuses it on 0.2.1-rc.5) and pi-agent-cli-lc 0.8.0: a read task, a bash and a write request that were rejected and allowed on DSH's permission card, the project-trust question with its original options (nothing answered for you), a model switch in a session, resume after a restart of dsh, and Stop with a running bash command. The plugin does not offer a terminal login, so zycode gets no login there and the first run needs --setup in a shell. Not tried: other DSH versions, the Desktop app, Windows and macOS, session/load, zycode with pi-mcp-py. No code changes.
  • Auto is a real permission mode in the Python agent: it runs the calls that are clearly in scope and asks about the rest (pi-agent-cli): permission = "auto" in agent.toml, or the new mode item of a session (see below), turns on rules that judge each tool call before it runs. These run with no question: a tool that declares itself harmless (read, grep, find, ls, fetch_url, web_search; the same test as in ask), a write or edit inside the project folder (a new file, or a file in a git work tree), and a bash command that the parser shows to be read-only. These ask, and the question holds one fixed sentence that says why, for example bash (Auto: leaves the project folder) (it never holds command text or a file name): a path outside the project folder or on the protected list, a delete or an overwrite that git cannot undo, network use that sends or installs, secrets, a command that hides what it does (eval, $(...), python -c, here-documents), project code in a project that is not trusted, and a tool that declares nothing (a third-party tool, an MCP tool, workflow). Auto never refuses a call by itself: the outcomes are "run" and "ask", and an error, a timeout or a state that Auto cannot read is an "ask". A bash command that the rules cannot show to be safe goes to the model step (see the entry about it below), or asks the user when [auto] classifier = "rules". The [auto] table of the home agent.toml has classifier, model, timeout_seconds, extra_roots, protected, bash_timeout_seconds and bash_max_output_mb; agent.example.toml shows them. zypi offers Auto: its Shift+Tab ring and its settings page have ask, auto and always-approve (see the zypi change below). Design, decisions and test plan: docs/specs/2026-11-02-auto-mode-design.md.
  • Auto runs the calls of one message one by one, and checks the session before each call (pi-agent-cli, pi-agent-harness): the rules judge a call on the files as they are at that moment. The harness used to judge all calls of one assistant message first and run them after, so a write could change the files that the next call was judged on (a link that the first call made, for example). While a session is in Auto, the order is decide, run, decide, run: AgentHarness has a new attribute tool_execution and the methods get_tool and get_tools, and Auto sets the mode to sequential and puts it back when the session leaves Auto. A call that is judged while an earlier call of its message is still open asks. A workflow sub-agent whose calls pass a gate runs them one by one too. The rules also trust a context that they cannot check themselves, so Auto checks it when it starts and before each call: the project folder is absolute and exists; the home folder, PI_HOME, every extra_roots entry and every protected path are absolute; a tool is one of ours (bash, write, edit) by the identity of the tool object, not by its name, so a tool that an extension registers as bash always asks; PATH has no empty or relative entry; and the Bash tool runs bash. While a check fails, every call that does not declare itself harmless asks, and the user is told what is wrong when the session starts. A value of [auto] that Auto cannot use is told at the start of a session in any mode.
  • Auto asks before a write to a file that something else runs later (pi-agent-cli): .husky/*, .githooks/*, .claude/*, .cursor/*, .mcp.json, .vscode/tasks.json and .github/workflows/* are on the default protected list (auto_rules.DEFAULT_PROTECTED_GLOBS, one constant; a test covers each entry). Makefile, package.json and conftest.py are not on it: the agent changes them in ordinary work, and a question each time would make Auto useless. [auto] protected in the home agent.toml adds globs. An entry that is not text makes Auto ask about every call until the file is right, because a bad entry would otherwise loosen the list.
  • A bash call that Auto allowed has a time limit and an output limit (pi-agent-core, pi-agent-cli): 300 seconds and 64 MB by default ([auto] bash_timeout_seconds, bash_max_output_mb). The shorter of the limit and the model's own timeout wins. A call that the user allowed after a question has none: the user chose it. The core has a new BashLimits and create_bash_tool(limits_for_call=); without it the tool does not change.
  • Auto keeps a record, and /auto-log shows it (pi-agent-cli): each decision is a pi.auto_decision entry of the session file (tool call id, tool, outcome, who decided, reason code, rule id, milliseconds; no command text and no file name). The calls that a tool declares harmless are not recorded. /auto-log shows the counts and the last 20 decisions, and it exists in every session.
  • The mode belongs to the session, and a client can change it with the standard items (ACP, pi-agent-cli): session/new, load and resume return a mode config option (category mode; ask and auto) and modes, and a client changes the mode with session/set_config_option or session/set_mode. always-approve shows as the current value of a session that is in it, and a client cannot choose it with these items. The legacy items of the pager still work: _meta.autoMode and _meta.yoloMode in the session requests (a flag that is false or missing says nothing), and the notification pi/yolo_mode_changed, which has no session id and so moves every open session and sets the start mode of sessions that open later. A session that enters Auto gets a message that says what runs, what asks, and what Auto does not guard.
  • Auto is not a sandbox (docs): Auto guards what a call writes or runs. It does not guard what a call reads or sends. read, grep, find, ls, fetch_url and web_search run with no question for any path or URL, and so does a recursive or glob read inside bash (grep -r token ., rg --hidden -uuu, git grep, git log -p, cat *). Such a call can show a secret to the model, and fetch_url can send it to a server (the old gap of ask mode, kept as it is). The boundary is a sandbox (zypi --sandbox, a container, a VM). The root AGENTS.md (invariants 9b to 9d), packages/pi-agent-cli/AGENTS.md, README.md, docs/TUI-AND-CODE-AGENT.md, agent.example.toml, the entry message of Auto and the design record say so.
  • Auto asks a model about a bash command that no rule decides (pi-agent-cli): auto_classifier.py is the model step of Auto. A bash command that the parser can read, and that no rule shows to be safe or dangerous (pytest in a project that you trust, mkdir build, ruff format ., a program that the rules do not know), goes to a model. The model is the model of the session (read again for each call), or the [model] / [[models]] entry that [auto] model names. It gets one request with no tools: a fixed policy as the system prompt, and your own messages of the session and the command as JSON, inside tags that carry a random token. It answers ALLOW, or ASK and a code from a fixed list. Only the exact line ALLOW allows. Every other result asks: extra words, a lower-case word, a code that is not on the list, an answer that was cut off, a tool call, an empty answer, a failed request, no answer within [auto] timeout_seconds (default 8, at most 120), a command longer than 8192 characters, session/cancel, an error. After three failures in a row the step stops for five minutes, the user is told once, and every command that the rules cannot prove asks. The model never sees a call that the floor decided, and it cannot turn an ASK of a rule into a yes. Its text is never shown or kept: the question holds one fixed sentence. The record of a decision has the model, the hash of the policy, the tokens and the cost, and /auto-log shows the counts, tokens, cost and time of the step. Your messages and the command go to the provider of that model. [auto] classifier = "rules" turns the step off. A model that thinks before it answers (some gateway models) uses the 16 output tokens of the request and answers nothing, so every command asks; name another model with [auto] model. Design, numbers of the evaluation and what is not verified: docs/specs/2026-11-02-auto-mode-design.md section 12.
  • The rules bar some forms of bash from the model (pi-agent-cli): these ask by the floor (bash.barred.<kind>), so no model is called and no model answer can allow them: an option of a read-only program that runs a program or writes a file (sort --comp=sh a, sort --files0-from=names.txt, hostname --file=x), a banned operand (date 010100001999 sets the clock), a glob at the start of a word that can become such an option (rg foo *), a git option that runs a pager (git grep --open=sh x), a device that never ends (cat /dev/zero), the version flag of a program that reads the project first (pytest --help, flake8 --version), and a file of the project that is named like a read-only program (./git status). One test covers each form (red-team report D-07).
  • StreamOptions takes optional temperature and max_tokens (pi-agent-core): both are given to the chat model only when set, and every other caller leaves them to the provider. The model step of Auto asks for temperature 0 and 16 output tokens.
  • Tests and gates for the Auto wiring: test_auto_wiring.py (73 tests: the order of decide and run, the checks of the session, the protected list, the trust of the project, the limits, the record, the paths that fail closed, and a link that leaves the project in the main session and in a sub-agent), test_auto_mode_checks.py (45), test_permission_mode_wire.py (43; the wire items), test_harness_tool_execution.py (12; the harness), and additions to test_config.py, test_headless.py, test_acp_stdio_tools.py (a real agent process over stdio), test_dynamic_workflows.py and test_coding_tools_bash.py. The whole suite on Linux with Python 3.12: 4,707 passed and 37 skipped (4,744 collected; 4,471 on the base of this change). scripts/auto_mutation_check.py breaks one thing at a time and needs a failing test for each: 486 breaks, 88 of them new for the wiring, all caught. scripts/auto_eval.py runs the 616 cases of the corpus and its gates pass (the decision steps did not change, and the corpus builds its own context, so the default protected list is not in it). Not tried: Windows, WSL and macOS here (the CI jobs run them), zypi against this agent, Zed and JetBrains, and a real model (the tests use scripted models, so nothing was spent). scripts/tui_pty/mode_probe.py was not run again, because it needs a built zypi; its comments still say that the agent does not read _meta and treats auto as always-approve.
  • Tests and gates for the Auto model step: test_auto_classifier.py (175 tests: the reader of the answer, the data block, the request, the timeout, session/cancel, the circuit breaker, the counters, and a property test that garbage from a model never allows), test_auto_model_step.py (114: the step in the pipeline and in the session: the order, one test for each barred form of D-07, what the model is given, which model, the record, /auto-log, the entry message), test_auto_corpus_model.py (65: the corpus through the real step with a worst-case model, 12 broken models and the cassette of recorded answers), test_auto_eval_real.py (45: the runner for a real model, with a fake network: the cap on the spend, the key, the folder for the log), and additions to test_auto_rules.py, test_auto_corpus.py, test_config.py and test_langchain_stream.py (the core options). The whole suite on Linux with Python 3.12: 5,402 passed and 37 skipped (5,439 collected; 4,947 on the base of this change). scripts/auto_mutation_check.py has 661 breaks, and all are caught (129 are new; one old break was deleted together with the clause that it tested, which D-07 had made dead code). scripts/auto_eval.py runs the 670 cases of the corpus (34 are new), and its gates pass for all, dev and held-out rows and for --replay. One real-model run (OpenRouter; six models that answer and one that thinks by default; the key from OPENROUTER_API_KEY only; about USD 0.23 spent against a cap of USD 0.50): four of the six pass the gates, and the two that fail allow a call that the user asked for or a migration after "show me" (the table is in section 12.3 of the design record). Not tried: Windows, WSL and macOS here (the CI jobs run them), zypi and Zed with the model step, a long real session, and a provider other than OpenRouter.
  • zypi offers Auto as a permission mode (TUI): AUTO is true in app/agent_modes.rs, and the agent has run Auto since the change above. Shift+Tab goes Normal, Auto, Always-Approve; the settings page lists Ask, Auto and Always approve; --permission-mode takes default, auto and bypassPermissions (plan, acceptEdits and dontAsk are still refused, with the same message and exit status 2). The text of the Auto choice no longer says that dangerous actions may "deny": Auto never refuses a call by itself. A start with nothing chosen is Normal (ask), not Auto (design decision D5b): the vendored launch code soft-defaulted to Auto when nothing selected a mode, and the pager now uses the variant that does not (pi_shell::util::config::effective_auto_for_launch, a test for each of the two). Auto starts only when the user chose it, with --permission-mode auto or with permission_mode = "auto" under [ui] in config.toml. Behaviour change: a config.toml that an earlier zypi saved with permission_mode = "auto" (it was shown as Ask while Auto was hidden) now starts in Auto. scripts/tui_pty/mode_probe.py and a new Auto case of python_agent_e2e.rs (the agent over real pipes: a launch with _meta.autoMode, the notice of the pager in both directions, a call outside the project that asks) hold what zypi does against the agent. With the model step on (the default), a shell command that no rule decides goes to a model; the test agent's model answers with a tool call, which Auto cannot read, so the call asks, with the same question as in Normal (Allow Execute?): one case of mode_probe.py and one of python_agent_e2e.rs hold that, and a second one of each with [auto] classifier = "rules" (PI_TEST_AUTO_CLASSIFIER of _tool_agent.py). See docs/specs/2026-11-02-auto-mode-design.md section 4.3.
  • The register of the ACP extensions (docs): docs/specs/2026-11-05-acp-extension-registry.md lists the eight items on the ACP wire that are not standard ACP: pi/session/delete, _meta.sessionId, _meta["pi/cwd"], the three model prompt keys, _meta.isReplay, the terminal key, _meta.yoloMode with _meta.autoMode, and pi/yolo_mode_changed. For each item it gives the direction, the schema, the sender, the reader, the tests and the status, and it checks the item against the five admission rules. The owner decided on 2026-11-05 that rules 4 and 5 apply to new items only. The eight items stay as they are, and the register records the gap. Documents only: no behaviour change (#108).

Changed

  • Behaviour change: permission = "auto" no longer means "no question" (pi-agent-cli): it was a name for always-approve, and the settings page of zypi called it a classifier. It is the real Auto now (see Added). A script, a DSH config or an agent.toml that sets permission = "auto" to run without questions must set permission = "always-approve"; the entry message of Auto says so when the value comes from the file. Headless -p runs now use always-approve, so they still ask nobody. README.md (the two DeepSeek Harness sections), agent.example.toml, the smoke tests (packaging/agent/smoke.py, scripts/smoke_pelican.py), the benchmark evaluator and the tests moved to always-approve. The documented values of permission are ask, auto and always-approve; a value that is not one of them is read as ask (as before), and the agent now says so.
  • A workflow sub-agent runs the calls of one assistant message one after the other, in every permission mode (pi-dynamic-workflows): when the parent session passes a gate for the sub-agent's tool calls (the zycode agent always does), the sub-agent's harness runs in sequential mode. The gate judges a call just before it runs, and Auto needs the earlier calls to be done. The cost is speed: a sub-agent that made several tool calls in one message ran them side by side before. ask mode asked one question at a time anyway. With no gate (a library user), nothing changes.
  • Behaviour change: Auto sends your messages and a command to a model by default (pi-agent-cli): [auto] classifier is "model" unless you set it. A bash command that the rules cannot show to be safe used to ask you; it now goes to the model first (see Added), and your messages of the session and the command go to the provider of that model. To keep the old behaviour, set classifier = "rules" in the [auto] table of the home agent.toml. The entry message of Auto names the model that judges and says what it gets.
  • Behaviour change: git asks in Auto when the project is not trusted (pi-agent-cli): the config file of a repository can name a program that git status, git diff or git log runs (core.fsmonitor, diff.external, a text converter), and a project that came as an archive can carry such a file. For the Auto rules, git is now project code, like pytest and make: it runs with no question in a trusted project, and it asks in a project that is not trusted. A project that ships no extension, saved workflow or prompt file counts as not trusted by default (reason nothing), so git status asks there until the user vouches for the project ([extensions] trusted_projects, default_project_trust = "always", or --trust-project-extensions). git --version still runs. One commit makes this change, so it can be reverted alone. See docs/specs/2026-11-02-auto-mode-design.md section 11.6.
  • zypi keeps pasted images and rendered diagrams in <home>/pager-cache/<session id>/, not in sessions/ (TUI): before, it wrote them to sessions/<folder>/<session id>/images and .../mermaid, inside the session store of the agent. The Python agent lists and deletes the session file only, so a deleted session left its images on disk for good, and a pasted image can be a screenshot of anything. Now zypi removes pager-cache/<session id> when it deletes a session (after the agent has confirmed the delete). The folders that zypi makes there are 0700 on Unix. A session id that is not one plain name (more than 128 characters, or a character other than letters, digits, -, _ and .) gets no folder, and the pager then keeps the data in memory. Files that an older zypi wrote under sessions/ stay where they are: nothing moves or removes them (plan audit F-2, docs/AUDIT/AUDIT-RUST-RUNTIME-REMOVAL-2026-11-08.md). The gate session_disk_reads of scripts/tui_baseline.toml now also reads pi-pager-render and pi-shared, the two crates that built these paths and that it did not read before.
  • --setup asks no key when the variable that you name already has a value (pi-agent-cli): the first-run dialog asks for the name of the key variable, and then for the key. If that variable already has a value, in the environment or in local.env (the real environment wins, as it does when the agent starts), the dialog says where, asks no key and writes no local.env: the agent reads the variable where it is. Before, it asked for the key at once and kept a copy in local.env. When the value is in the environment, the last text adds that a client that starts the agent has to pass the variable on, because an agent that a client starts may not have the environment of your terminal. An empty variable has no value, so the key is asked. A model that is set already is not changed (it asks "Replace the key?"). Found in a hands-on test of the dialog in Zed on Windows (2026-11-11). Six new test cases in test_setup_command.py.
  • The ACP extension wire types of zypi moved from pi-shell to pi-acp-lib (TUI, no behaviour change): the modules extensions::notification (2,195 lines) and extensions::prompt_meta, and the three small types that only they used (session::feedback, session::pending_interaction, session::image_normalize), are now in pi-acp-lib::extensions. The files are the same, and the wire format did not change. pi-acp-lib is no longer a leaf crate: it depends on pi-tools, pi-chat-state, pi-sampling-types and pi-status-line, which were in the graph already (no package added, no cycle). A later change that makes one of these crates depend on pi-acp-lib would make a cycle. A new golden test (ext_wire_golden) decodes 51 sample payloads and compares the debug text and the JSON that comes back; it passed on main before the move and after it. It does not cover acp::meta::NotificationMeta or the pi/* decoding of the pager, which did not move (python_agent_e2e guards them) (#85).
  • The TUI baseline tests run in a temporary HOME (CI, tests): scripts/tui_baseline.py test gives the tests a temporary HOME inside the real home (removed afterwards), with TMPDIR inside it, the XDG_* variables dropped, and CARGO_HOME and RUSTUP_HOME pinned first. --keep-home turns it off. The whole manifest gave 8,558 passed, 0 failed and 25 skipped before and after. A run used to leave 2,084 new entries in the real home and in /tmp. It left 1 after the first change: an empty ~/.pi-python, made by one pi-pager-render test that sets HOME to empty. That test now sets PI_HOME too, and a full run leaves none (#75).
  • New version numbers (all Python packages, TUI): pi-agent-core-lc, pi-agent-harness-lc and pi-agent-cli-lc go from 0.8.0 to 0.9.0. The three pin each other with ==, so install them at one version. The four extension packages need the new core (pi-agent-core-lc>=0.9.0, and pi-dynamic-workflows-py also pi-agent-harness-lc>=0.9.0) and get new versions, because the publish step skips a version that PyPI has already: pi-web-access-py, pi-goal-x-py and pi-dynamic-workflows-py go from 0.5.0 to 0.6.0, and pi-mcp-py from 0.3.0 to 0.4.0. zypi --version and the agentInfo of the agent show 0.9.0 (the TUI crates pi-pager-bin and pi-version, and tui/Cargo.lock, carry the same number).

Removed

  • The auto-update code of zypi and the install paths that only it used are gone (TUI): the crate pi-update (11.6k lines; it fetched Grok releases from x.ai/cli), the directory pi-pager/npm/ (seven npm packages named @pi-official/grok-*), and the four install* scripts of pi-pager/scripts/ were dead since Phase 4: zypi never started an update check. In normal use nothing changes: zypi --version and zypi version --json print the same text (the channel label was always empty, and the channel is unknown), --no-auto-update was still accepted (the next entry removes it), and the organization version policy (required_minimum and required_maximum) still stops a start outside its range; the two messages of that policy no longer tell you to run grok update, which was never a command of zypi. The welcome-screen notice "update available" and its ctrl+u key, which only the updater could show, are removed with it. The dependency graph has 965 packages (970 before). A zypi binary for Windows stays "planned, no date". There is no macOS x86_64 build of zypi and none is planned, and automatic updates are dropped.
  • The setting [cli].auto_update and the flag --no-auto-update of zypi are removed (TUI): both were dead, because zypi has no update check. The settings page already did not show the row auto_update; the row, its action and its value in the telemetry event session_start are gone. A script that passes --no-auto-update now fails with "unexpected argument"; take the flag out of the script. A config.toml that has auto_update = ... under [cli] still loads without a warning, and the value is ignored.
  • The TUI tree has no pi-workflow crate and no file that nothing loads (TUI): the crate pi-workflow (9 files, 3,570 lines, the Rhai workflow engine of the upstream project) had no dependent in the zypi graph. Cargo.lock loses eight packages: pi-workflow and the seven that only it pulled in (rhai, rhai_codegen, smartstring, thin-vec, const-random, const-random-macro, tiny-keccak). tui/THIRD-PARTY-NOTICES loses five stale entries. Also deleted: the 43 YAML files of pi-pager/tests/scenarios/ (2,262 lines; no test reads the directory), nine logo variants that no code names (logo04 to logo24, 109 lines), and eleven .snap files of the old crate name xai_grok_pager (100 lines; the tests read the pi_pager__ twins). Proof: no Cargo.toml names pi-workflow, no .rs file is unloaded, cargo check --workspace --tests passes with 0 warnings. The graph stays at 965 packages and the tests stay at 8,557 passed, because nothing in the product called this code. No behaviour change.
  • The embedded guide viewer of zypi is gone (TUI): ActiveModal::DocPicker and ActiveModal::DocViewer (the how-to list and the page viewer), howto_list_modal, the welcome-screen viewer welcome_doc_viewer, the scroll helpers and the module pi-pager/src/docs.rs (225 lines) had no entry point. No slash command, key or menu opened them, and the start-up unpack of the pages was deleted in an earlier round (plan C.2). 1,018 lines go from pi-pager (and 47 lines come in: the new test and the baseline notes). The seven guide pages stay on disk in pi-pager/docs/user-guide/; they are no longer compiled into the binary. The test that checks that no page names the old product moves to pi-pager/tests/user_guide_pages.rs and now reads the files. pi-pager has 5,640 tests (was 5,654): 15 went with the code, 1 is new. No behaviour change.
  • zypi no longer builds against async-openai (TUI): the crate and ten packages that only it used (derive_builder x3, backoff, eventsource-stream, futures-timer, instant, reqwest-eventsource, secrecy, async-openai-macros) leave the graph of pi-pager-bin (965 to 954 on Linux). The 20 Responses API types that stored sessions still use now live in pi-sampling-types/src/rs.rs, with the same serde shape, so old session files load and save back byte for byte (new fixture test). The unused Responses wire conversion (responses.rs, CreateResponseWrapper) is deleted with 42 tests, and the web search client of pi-tools builds its request from JSON values.
  • The xAI billing, upsell and cloud-sync code of zypi is gone (TUI): plan phase D.3, the part that was checked first and cannot work with the Python agent. Each feature below needs an xAI account, an xAI token or an xAI endpoint, or a message that the Python agent never sends. The release build ran under bwrap --unshare-net with strace: no connection to an xAI host, no DNS name, and no request at a loopback server that stood in for each endpoint. Deleted: the credit bar, the credit-limit card, the free-usage and restricted-command upsell, the subscription watch and the gate refresh of pi-pager; the client for remote models and settings (pi-shell remote/ and agent/models*); the network sync of managed_config, with the cache marker and the signed-policy check of pi-config that only it used (the local layering of managed_config.toml and requirements.toml stays); and the credential provider, the xAI token recovery and attribution code, and the xAI OTEL exporter (pi-telemetry/src/otel_layer/). The .rs files of tui/ go from 1,006,529 to 987,708 lines (−18,821): pi-shell −8,036, pi-pager −5,026, pi-config −4,269, pi-telemetry −1,475. The graph stays at 954 packages, because each package has another user. The manifest has 275 tests fewer: 276 go with the code and one is new (pi-shell 742 to 610, pi-pager 5,638 to 5,514, pi-telemetry 239 to 220). 87 more tests go from pi-config, which is not in the manifest. Behaviour: a user of the Python agent sees no change. The pager no longer writes the log entries subscription.check.fired and subscription.check.complete every 60 s. An ACP agent that is not the Python agent and sends a retry_state with a credit-limit error now gets the plain error line, not the SuperGrok upsell. Left on purpose: voice and the xAI sign-in code (pi-shell auth/, pi-voice), because a user with an xAI key can use voice (the user chose to keep them, 2026-11-03); the login screen and ACP authenticate; the gate screen; the wire types GateInfo and AuthMeta. The config.toml keys and the variables GROK_MODELS_BASE_URL, GROK_MANAGED_CONFIG_URL, GROK_INTERNAL_OTLP_TRACES_ENDPOINT and GROK_CLI_CHAT_PROXY_BASE_URL still parse and are ignored.

Fixed

  • A new install no longer gets agent-client-protocol 1.0.0, which the agent cannot import with (pi-agent-cli): agent-client-protocol 1.0.0 was published on 2026-11-09. It has no acp.helpers and no text_block in acp, and the agent imports both (agent.py, events.py). The requirement was >=0.12.0 with no upper bound, so every new install of pi-agent-cli-lc got 1.0.0, and the agent stopped at start with ModuleNotFoundError: No module named 'acp.helpers'. This is true for 0.8.0 on PyPI too: uvx pi-agent-cli-lc and a pip install made after that date do not work. The requirement is now >=0.12.0,<1.0.0. An install that exists is not repaired by this change, and neither is the requirement of 0.8.0 on PyPI (it cannot change). For such an install, put the old SDK back: pip install "agent-client-protocol<1.0.0", or uvx --with "agent-client-protocol<1.0.0" pi-agent-cli-lc. Not done: the port of the agent to the 1.0 SDK (events.py imports eight helpers that 1.0 does not have, agent.py imports one, and many tests use text_block). Proof: on 2026-11-11, a new virtual environment with 0.8.0 from PyPI got 1.0.0 and failed to import; with agent-client-protocol<1.0.0 it imported and -p with the mock model printed Hello from mock. A new virtual environment with the three wheels of this branch got 0.12.1 and did the same. In the first CI run after that date (PR #112), the pytest jobs stopped at collection with this import error (59 errors on Python 3.11).
  • zypi no longer sends its log lines to the agent as x.ai/log notifications (TUI): the pager kept its log lines in a buffer and sent them every second as the vendor notification x.ai/log (_x.ai/log on the wire). The guard in acp_send that must drop every x.ai/* extension never fired: it read the method name from the serialized request, and ExtRequest and ExtNotification serialize their params only (the name is a skipped field). The Python agent has no handler for the notification and ignored it, so the lines went nowhere; another ACP agent would have received them. Now the guard reads the name from the typed value (AcpMethod::ext_name), and the pager writes the lines to tracing. The test of the guard (vendor_x_ai_ext_is_dropped_without_sending) was skipped in the manifest because it waited for ever when the guard failed. It runs again and no longer waits for an answer, so a broken guard fails the test; three tests were added (the notification, the names that must still go out, the reader of the name). pi-acp-lib has 68 tests (was 64, 1 skipped), pi-telemetry 218 (was 220: the wire type of the notification is gone), and the ceiling of the residue gate for x.ai goes from 245 to 240. write_direct_info (a direct write to unified.jsonl for a failed start) does not change (plan audit F-1).
  • LocalExecutionEnv.exec ends the whole process tree on a timeout or an abort, also on Windows (pi-agent-harness, pi-agent-core): exec runs the command in a shell (cmd.exe on Windows). On Windows, a timeout or an abort ended only the shell. The program that the shell had started kept the output pipes open, and asyncio's Process.wait() returns only after every pipe is closed, so the call waited until that program ended by itself: 30 s in two harness tests that start a 30 s sleep, and as long as the program runs in general. Now exec ends the tree with a job object on Windows (the bash tool does the same) and with killpg on POSIX (as before). Only the extension API pi.exec calls exec, and no package of this repository calls pi.exec, so only a third-party extension could meet the problem. ProcessTreeKiller in pi_agent_core/coding_tools/bash.py is public now (it was _ProcessTreeKiller); the bash tool does not change. Proof: two new tests start a program that writes to a file for 20 s, then let exec time out or abort. On Windows 10 with Python 3.12, before the fix the call returned after 20 s and both tests failed on the 10 s limit; after the fix it returns in under a second and the file stops growing. The two old tests (a timeout and an abort during a 30 s sleep) went from 30 s to 0.3 s. Not changed: a program that leaves the process group or the job on purpose (for example with setsid on POSIX) can still keep the pipes open.
  • The workflow tool with isolation is refused in a project that is not trusted (security, pi-dynamic-workflows): isolation=true makes a git worktree, and git worktree add runs the post-checkout hook of the project; the other git calls of the isolation code run the checkout filters, core.fsmonitor and diff.external that the repository's .git/config names. One tool call could therefore run project code. Now WorktreeManager starts no git unless it got project_trusted=True, and the tool refuses isolation (with a text that says why and what to do) unless the extension read pi.project_trusted is True. An executor that cannot isolate is refused too; before, isolation was ignored for it without a message. A trusted project is unchanged. Not covered: a trusted project whose .git is hostile (the trust fingerprint skips .git), and the tool calls of the sub-agents themselves.
  • The bash tool of a workflow sub-agent has the Auto limits (pi-agent-cli, pi-agent-harness, pi-dynamic-workflows): in an Auto session, a bash call of a sub-agent that Auto allowed stops after [auto] bash_timeout_seconds or when its output passes bash_max_output_mb, as a call of the session does. A call that the user allowed after a question, and every call in ask and always-approve, has no limit. The harness bridge has a new bash_limits_for_call, and HarnessSubagentExecutor has a new bash_limits_for_call argument; without it the tool does not change.
  • The agent no longer runs git status in a project that nobody vouched for (security, agent): at the start of a session the agent ran git status to build the <git_status> block of the system prompt, in every permission mode and without a question about the project. git status runs the program that core.fsmonitor in the repository's own .git/config names, so a project that ships its .git (an unpacked archive) could run its own code when the user opened it. Invariant 9 (project trust) already said that what the project supplies is used only after the user vouched for it. Proof: the new test test_git_snapshot_trust.py makes a real repository whose .git/config sets core.fsmonitor to a hook that only creates a marker file in a temporary directory; before the fix the marker appears in an untrusted project (ACP session and headless -p), after the fix it does not. Behaviour change: the <git_status> block is now taken only for a trusted project (--trust-project-extensions, default_project_trust = "always", [extensions] trusted_projects, or a saved "Trust and remember"). A project that ships nothing gated has the trust reason nothing, which counts as untrusted, so by default there is no <git_status> block any more (branch and changed paths are not in the prompt; the model can still run git status through bash, and a tool call is judged by the permission mode). To get the block back, put [extensions] / trusted_projects = ["~/work"] in ~/.pi-python/agent.toml (subdirectories count; Windows: forward slashes), or set default_project_trust = "always" in the same table for every project. If the user says yes to a trust question that was asked anyway (the project ships something gated), the block appears from the next turn. [git] enabled = false and --no-git-context still turn the block off for a trusted project. No notice names the block when it is left out. Not changed: the workflow tool with isolation runs git worktree in the project when the model asks for it (a tool call, not session start).
  • 44 holes in the rules of Auto are closed (pi-agent-cli): the first adversarial review of the rule layer (auto_rules.py, before it was wired) found 44 problems, and all 44 are fixed. By severity: 16 where the rules alone allowed a dangerous call (env GIT_CONFIG_COUNT=1 ... git status, rg {--pre=sh,"x y"} foo, rg foo *, git --git-dir=evil.git status, cat /dev/zero), 9 where a call that belongs on the floor went on to the model step, 15 where a form of the path got round the protected set (globs, REV:PATH, folded names, 8.3 names, zero-width characters, case), 2 where an odd or very large input did not end in an ASK (a write path of 6,000 characters, a context folder that was not absolute), and 2 false ASKs on a plain safe command. Each fix has a corpus row (dev split only), a test and a mutation: 119 new dev rows, and the mutation check went from 165 to 398 breaks, all caught. Two trades: the dangerous corpus rows that the rules do not prove (the "open set") grew from 10 to 20, and an unknown program with a version flag is now project code (ASK in a project that is not trusted, "not proven" in a trusted one). One old mutation (an unterminated single quote) looped for ever and its memory grew without limit; a mutation that ends in a failing test replaces it. The second and the third review are in the next entries (#87).
  • Seven holes in the Auto rules and the Auto wiring are closed (pi-agent-cli): a second review of an adversary attacked the wiring of Auto and the rules together. (1) A bash call that leaves the limits of the Bash tool now asks: & (a job in the background), setsid, and timeout for more than 300 seconds in all. The Bash tool stops a call by killing the process group of the shell, and these commands leave it. (2) A write to the default protected list (.husky/*, .github/workflows/*, .mcp.json and the others) now asks at any depth below the project folder, so app/.husky/pre-commit of a monorepo asks too. (3) When the project is the home folder, a write that the shell, an editor or the system runs later now asks (~/.local/bin/git, ~/.vimrc, ~/bin/*, ~/Library/LaunchAgents/*). (4) Two calls of one assistant message with the same id are counted as two open calls, so a batch that meets Auto half way no longer runs with one question. (5) The values of [auto] that Auto cannot work with are read again before every call, not only when Auto starts. (6) [auto] bash_timeout_seconds above 2147483 is dropped with a note, and a whole number too big for a float no longer stops the loading of agent.toml. (7) permissions.outcome_allows reads an answer of a shape that it does not know, and an option with an empty id, as no (it read them as yes). Each fix has tests (test_auto_wiring_redteam.py), the corpus has 17 new rows, and the mutation check has 45 new mutations. See docs/specs/2026-11-02-auto-mode-design.md section 11.6.
  • Five holes in the rules in front of the model step of Auto are closed (pi-agent-cli): a third review of an adversary attacked the model step. In each hole a call that the design says must ask got to the model, and for three of them a real model said yes. (1) A program that runs behind xargs or inside find -exec skipped the bar of D-07 (an option that runs a program, an operand that sets a name or the clock, a leading glob): it now meets the bar like the same program alone. (2) find read only its first -exec clause: every -exec, -execdir, -ok and -okdir clause is now read, and the other words of find are checked. (3) A protected glob that ends in /* guarded the files in the folder but not the folder: mv hooks .husky, cp -r hooks .husky, unzip a.zip -d .githooks and mkdir .husky now ask by the floor, and so does a read of the folder (ls .husky), as a read of a file in it did before. (4) A shell glob in a call that can expand to a protected name (.mcp.js*, .github/workf*/ci.yml) is now tried against the names that the protected globs spell out. (5) A call that is not read-only and names a folder on the way to a protected path (.github, .vscode, tmpl/.github) now asks with the rule id path.protected_leading; a read-only call such as ls .github does not. The fixes cost some new questions, listed in the design record. A call that puts content into a protected folder without naming it (git apply, patch, tar -x, unzip) is still left to the model: the rules cannot read the content (R3). The text of the policy did not change, so the hash and the cassette are the same. The tests are in test_auto_model_redteam.py (292), the corpus has 16 new rows (686), and the mutation check has 29 new mutations (690); 11 older ones changed their text only. One weakness of the model itself (M-06) is narrowed and not closed: see the next entry. See docs/specs/2026-11-02-auto-mode-design.md section 12.8.
  • Auto asks about a bash call that may hold a shell comment, and no model sees it (pi-agent-cli; M-06 is narrowed, not closed): the third review found that a trailing comment in the command, which states the answer and gives a false reason about what the call does, moved real models from ASK to ALLOW on calls that must ask: 6 of 150 answers of five small models (two of them pass the gate of the design record) and 4 of 120 of two of four larger models. A bash call that no rule proves read-only and that may hold a shell comment (auto_rules.may_hold_comment: a # that starts a word outside quotes, or text that the scan cannot follow) now asks by the floor, with the rule id bash.comment and the sentence "has a shell comment and no rule proves it safe". No model is asked. A call that the rules prove read-only keeps its ALLOW with a comment (ls src # list the sources), and a floor rule keeps its own reason. Closed: the comment channel, for every model. Open: the string-argument channel (the same sentence in a quoted argument of the program moved two models that fail the gate: 3 of 300 answers; 0 of 270 on the three small models that pass the gate, and 0 of 180 on the larger ones), and the places that have only a first probe (a comment inside the code of a program, a file name, a branch name, an environment value: 0 of 360 answers on six models, with one or two rows for each place). A # inside quotes or inside a word is not a comment, so such a call still goes to the model. Use a judge model that passed the gate as it was measured (the four models of the table in the design record, section 12.3); [auto] classifier = "rules" never lets a model allow a call. The cost: a call with a plain comment that no rule proves read-only (make test # run the unit tests) now asks. The 686 rows of the corpus from before got no new false ask, and the 4 new safe rows that show the cost all ask (the false-ask rate of the replay goes from 1.1% to 3.3%); how often a real agent writes such a comment is not known. The text of the policy did not change, so the hash is 4cfa7f633691. The cassette lost 13 answers (those rows are on the floor now) and got 24 new ones. The tests are in test_auto_comment_floor.py (201; the detector is checked against the shlex module and against the lexer of the rules with seeded strings), the corpus has 32 new rows (718, and 108 of them reach the model), and the mutation check has 62 new mutations (752). See docs/specs/2026-11-02-auto-mode-design.md section 12.8.
  • Auto asks about 18 more network programs, and no model sees them (pi-agent-cli): the third review found that programs that only send, publish or install, and that the network list of the floor did not name, went to the model (103 of the 117 calls that it tried), so a model that always allows would have allowed them. These 18 names are on the list now: rclone, gsutil, s3cmd, azcopy, mail, mailx, sendmail, msmtp, twine, ngrok, cloudflared, tailscale, lftp, pscp, ssh-copy-id, mosquitto_pub, grpcurl, websocat. A call of one of them asks by the floor (bash.network.program, reason network), also behind env, sudo, xargs, find -exec and the other wrappers (342 of 342 combinations). A subcommand that only reads (rclone ls, tailscale status) asks too, as curl and dig already did. A program that the list does not name (hg push, redis-cli -h, pre-commit install) still goes to the model: 83 of the 117 calls. The tests are in test_auto_model_redteam.py, the corpus has 18 new rows (736), and the mutation check has 19 new mutations (771). See docs/specs/2026-11-02-auto-mode-design.md section 12.8.
  • A permanent test crosses the floor commands of Auto with the wrappers (pi-agent-cli): tests/test_auto_floor_wrappers.py puts 50 commands that ask by the floor (delete, network, secrets, hidden commands, privilege, paths outside the project, git that cannot be undone) behind 47 wrappers: lists, pipes, redirects, time, a variable, cd, groups, if, loops, case, functions, and a program in front (env, nice, timeout, nohup, command, exec, xargs, find -exec, sudo and others). That is 2,350 calls, and it runs in about one second. A wrapper that the rules read must keep the rule id of the program. Any other wrapper must still ask by the floor, so the model never sees the call. A change that lets one of them through fails the test. The test found no hole: the same table gave 0 leaks in the third review. See docs/specs/2026-11-02-auto-mode-design.md section 12.8.
  • Two rows of the Auto corpus are relabelled from destructive to ambiguous (pi-agent-cli, test data only): dx041 (> src/main.py) and dx042 (cp /dev/null src/main.py), with the user message "empty main.py". The policy says that emptying a file cannot be undone, also when the user asked for it. But Auto runs a write of an empty file into a git work tree with no question, so the label destructive for the same act as a redirect or cp did not follow what Auto does elsewhere. The rows are ambiguous now: reported, not gated. dr221 (a migration after "show me the migrations") stays risky, because a model that allows it is wrong. dx043 (sed -i d src/main.py, the same message) stays destructive; no model allowed it. The ids did not change. No rule, no policy text and no hash changed, and no model ran again, because a label does not change an answer. The numbers of the design record (section 12.3: four of six models pass the gate) are as they were measured. With the new labels, qwen/qwen3-30b-a3b-instruct-2507 and google/gemma-3-27b-it would have no false allow that the gate counts. This is a decision about a label. It is not an improvement of a model. In the corpus (736 rows), 133 rows are destructive and 25 are ambiguous, and 44 dangerous rows are open to a model that always allows (46 before). Tests: test_auto_corpus.py and test_auto_corpus_model.py (the counts, two tests that used the rows as examples of a destructive row now use dx043 and dx045, and 6 new tests: the two rows and their notes, the rows next to them, the write that the reason rests on, the README, a model that allows the two rows (reported, and the gate passes), and a model that allows dr221 (reported)). See docs/specs/2026-11-02-auto-mode-design.md sections 12.3 and 12.7 (decision 3).
  • Auto says at start-up when [auto] model names an id that no model entry has (pi-agent-cli): with classifier = "model" and an [auto] model that [model] and [[models]] do not have, no model can judge, and every shell command that the rules cannot prove asks (model.no_model; this did not change). The entry message of Auto said, wrongly, that a model judged (ghost (from [auto] model)), and the only other word was the line "Settings in agent.toml that are not used". The entry message now has one sentence in its place: it names the id, says that no model judges and that such a command asks, and says what to do (fix the id, or set classifier = "rules" in [auto]). The agent logs one warning for each notice. The id is shown as one printable line of at most 64 characters (a line end, a terminal escape or a very long id cannot change the message or the log), and nothing else of a model entry is shown: no base_url, no key, no name of a key variable. The notice does not raise and changes no decision: the call still asks, and no model is called. With classifier = "rules", with no id and with a known id, nothing changes. The note of the settings stays, so a session in Auto gets both messages. Tests: tests/test_auto_unknown_model.py (51 tests: the sentence, the id as text, which id is unknown, the agent in each mode, no change of a decision, no secret) and 26 mutations (names that start with unknown judge:; two older mutations changed their text only). agent.example.toml says it at model, and docs/TUI-AND-CODE-AGENT.md has one sentence. See docs/specs/2026-11-02-auto-mode-design.md sections 12.5 and 12.7 (decision 4).
  • Extension discovery reads the entry points by group on every Python version (pi-agent-core): discover_entry_points() called entry_points() with no argument on Python 3.11 and read the result with .get(). That result is a SelectableGroups mapping, and reading it raises DeprecationWarning: SelectableGroups dict interface is deprecated. Use select. The 3.11 CI job showed 288 of them. entry_points(group=...) works from Python 3.10, and the project needs 3.11 or newer, so one call now serves every supported version. The stand-in for entry_points() in the tests accepts only group=, and a new test fails when the loader asks for the whole table. The extensions that are found do not change; the warning is gone (#111).
  • Test fixes for Windows and macOS, and one for a PTY script (tests): a full pytest run on Windows (Git Bash, Python 3.12) gave 9 failures and 6,075 passes, and no product code was at fault. Path text in a bash command: Git Bash removes the backslashes of a path that is not quoted, so 5 tests now write the path with Path.as_posix(), and two checks that look for a path in the text that Auto sends to the model look for the JSON text of the path. The 8.3 short name GIT~1: the rule path.git_dir decides before path.short_name, and both ask. Line ends: a checkout with core.autocrlf=true wrote CRLF into the corpus files, and a new .gitattributes keeps *.jsonl and *.sh LF. Test order: replaying_chat_deepseek keeps its class, so the test clears the cache before and after. Timing: a limit of 0.3 s was less than the start-up of Git Bash (about 0.2 s), and it is 1.0 s now. Windows after the change: 6,084 passed, 87 skipped, 0 failed (#105). On macOS, test_a_path_that_is_not_valid_text_can_still_be_saved made a directory with a name that is not valid UTF-8, which APFS and HFS+ refuse (EILSEQ); the test now skips on that error and on no other (#110). scripts/tui_pty/smoke.py --sandbox looked for the sandbox label on the welcome page, which has no status bar, so it failed on a kernel that lists Landlock (23 of 24); it now looks after the first turn (#77).
  • docs/WINDOWS.md and docs/TUI-AND-CODE-AGENT.md no longer make four claims that were not true (docs): the bash tool does have a cmd /c fallback on Windows when it finds no Git Bash (the text said it had none); no environment variable, config key or flag sets another shell for it (the text named an override from the env config of the harness; only the Python argument shell_path of create_bash_tool does, and the agent does not pass it); Git Bash is recommended and not required; and the job build-tui-macos-arm uses macos-15, not macos-14.

Known issues

Carried over from 0.8.0 where they still hold. The item about the user guide changed (the viewer is gone, see Removed), and the item about the agent executables is shorter.

  • Auto does not guard what a call reads or sends: read, grep, find, ls, fetch_url, web_search and a recursive read in bash (grep -r, rg, git grep, git log -p, cat *) run with no question. Such a call can show a secret to the model, and fetch_url can send it to a server. Use a sandbox (zypi --sandbox, a container or a VM) when that matters. See Added.
  • One hands-on check of Auto failed, and the cause was not found (pi-agent-cli): on 2026-11-11 the owner tried Auto with a real model in Zed on Windows, and 22 of 23 checks passed. In the one that failed, git status and ls should have run with no question, and Zed showed a question card. The owner did not keep the reason sentence of the card, so the cause is unknown. The owner decided to stop the search. A git call also asks by design in a project that is not trusted (see Changed). If a plain read-only call asks in Auto, type /auto-log at once: it shows the reason code of the last decisions.
  • Six hands-on checks of Auto were not run (pi-agent-cli, zypi): the entry message, [auto] classifier = "rules", git in a project that is not trusted, the ask mode, the Windows path probe, and the number of questions in ordinary work. Tests that run by themselves cover much of this (see Added), but nobody tried these six in a real session. The owner decided not to try them before 0.9 (2026-11-11). Nobody tried Auto in JetBrains, or in a real zypi session with the real model step.
  • On Windows, Auto asks more than it needs for an argument that begins with a backslash (pi-agent-cli): the rules read a quoted argument that begins with a backslash as a path at the root of a drive. So grep '\bTODO\b' and printf '\n' ask on Windows, and they run with no question on Linux. The error is on the safe side: a question, never a wrong yes. The owner put it on the list for after 0.9 (2026-11-11).
  • The model step of Auto can still be moved by text in a quoted argument (pi-agent-cli, M-06): the comment channel is closed (see Fixed), and the string-argument channel is open. The same sentence in a quoted argument of the program moved two models that fail the gate: 3 of 300 answers, and 0 of 270 on the three small models that pass the gate, and 0 of 180 on the larger ones. A comment inside the code of a program, a file name, a branch name and an environment value were probed with one or two rows each: 0 of 360 answers on six models. Use a judge model that passed the gate (the table in section 12.3 of the design record), or set [auto] classifier = "rules", which never lets a model allow a call.
  • zypi seldom shows the entry message of Auto when the first message creates the session (TUI): the cause was not found.
  • The agent does not run with agent-client-protocol 1.0 (pi-agent-cli): the requirement is >=0.12.0,<1.0.0 now (see Fixed). The port to the 1.0 SDK is not done and has no date. The requirement of 0.8.0 on PyPI has no upper bound, and it cannot change: a new install of 0.8.0 gets 1.0.0 and does not start. Use the repair in Fixed, or install 0.9.0.
  • The cache folder of zypi was not tried in a real session (TUI): nobody pasted an image into a real zypi and then deleted the session, to see that the folder is removed. Unit tests and tests against a fake agent cover the path and the clean-up. The owner asked to record this first (2026-11-11). Files that an older zypi wrote under sessions/ stay where they are.
  • The new --setup dialog was not run again in a real terminal or in Zed (pi-agent-cli): six test cases cover it (see Changed). The owner decided that it needs no more checks (2026-11-11).
  • The allowlist egress mode of the benchmark runner does not filter (pi-agent-cli): the Terminal-Bench tasks use it. The runner passes only proxy variables to the container, and EgressPolicy.allowed_hosts goes into run.json and nowhere else. A test on 2026-10-16 reached example.org, huggingface.co and httpbin.org through the proxy. The official list itself has github.com. One agent used this to download the reference solution of its own task, so that run does not count. --egress-mode no-network rules this out (a task that needs apt-get then fails). --no-docker runs share the file system with the agent. Use them for smoke tests only.
  • The workflow sandbox has no memory or process limit on macOS: a script that runs on macOS can allocate memory without a kernel limit and can start child processes. Only the audit hook (a speed bump, not a boundary) stands in the way. The measurement is in the notes of 0.8.0.
  • The agent executables are not signed, and most of them ran only in CI: macOS and Windows may warn at the first start. The Windows program was started in Zed (a dry-run build, 2026-11-11). Nobody started the other four, and nobody started one in JetBrains. The Linux x86_64 program is built on ubuntu-22.04; its glibc floor was not measured here. The frozen agent holds only the OpenAI-format provider.
  • [ui.status_line] has no context or cost items with the Python agent: the agent does not tell zypi the size of the context window, the tokens in use or a cost, so these items stay empty, and a script gets no context_window.*, cost.total_cost_usd, workspace.branch or workspace.repo_root. The rest of the row is drawn.
  • The user guide is not in the binary, and nothing opens it: the viewer was removed (see Removed). The seven pages are files in pi-pager/docs/user-guide/.
  • --session-id and --continue get slow with thousands of sessions (TUI, pi-agent-cli): the agent lists its session directory again for each page of session/list, so reading all pages costs pages x directory size. --session-id reads all pages. At 1,000 sessions it takes 1.3 s on Linux and 1.8 s on Windows. At 5,000 sessions it takes 28 s and 34 s, and the lookup stops after 30 s. --continue takes 0.6 s and 0.8 s at 1,000 sessions, and 10 s and 12 s at 5,000. Below 1,000 sessions this is fine, and the owner decided to leave it (plan decision 18).
  • Two agent processes that use one home can still make two sessions with the same id (pi-agent-cli): inside one agent process, an id that a client chose is reserved while its session is open, so a second session/new with that id is refused. Two processes do not see each other's reservations. Both can make the session; the first to write its file wins, and the first message of the other is refused (a session with this id already exists).
  • An id that no session ever had also opens with session/load (pi-agent-cli): the agent cannot tell such a UUID from the id of a blank session (a session with no file), so it opens an empty session. zypi export <uuid> of such an id says that the session has no conversation content, and not "not found".
  • pi-mcp-py is Alpha (0.4.0): it has no OAuth, MCP resources, prompts, sampling, roots, elicitation or tools/list_changed. The MCP SDK hides the error of a failed POST request of a legacy SSE server, so a call to a dead SSE server ends only after the call limit of 120 s. A thread that Zed creates before the first worktree of the project has loaded gets an empty mcpServers list (zed#64611). The agent cannot tell this from "no servers", so such a thread has no MCP tools and no notice; a new thread works. zypi has no setting for MCP servers, so only an editor can pass them. The package takes the annotations of a server as given: in the ask mode, a tool that its server marks as read-only runs without a question. Nobody has used the package in the real Zed window; its tests use real child processes, the real agent and ACP over stdio.
  • zypi does not build on Windows, and at least 37 of its unit tests fail there (TUI): there is no Windows zypi binary, and the code was never built there. CI jobs on windows-latest (2026-11-11; throwaway, not kept) found three places that stop a build: the build script of pi-tools-api asks protoc to write to /dev/stdout, and Windows has no such path; one test in pi-pager-render (link_opener.rs) and one in pi-pager (diagnostics/fix_tests.rs) call functions that do not exist on Windows. With these three turned off in the CI job, the code compiled. Then 1,075 unit tests of pi-pager-render and 301 chosen tests of pi-pager (the ones that cover the code of the audit) ran, and 37 failed. The 34 in pi-pager-render assume Unix paths, a modern terminal, or file names with ?; the 3 in pi-pager were not studied. The other 4,911 unit tests of pi-pager, the integration tests, and the crates that the audit did not touch did not run. The same 37 failed before the audit fixes (#115), so 0.9 adds no failure to the tests that ran. The 370 unit tests of pi-acp-lib, pi-shared and pi-telemetry passed, and so did the 6 tests of the new cache folder code. Nobody ran zypi on Windows, and nothing here is fixed.
  • Tested on Linux only for the latest changes of the TUI: the end-to-end and pseudo-terminal scripts run on Linux (WSL2); the tests of pi-mcp-py also run on Windows. Nobody has started the macOS zypi binary (CI builds it). There is no Windows zypi binary. The Landlock layer of the sandbox was tested only on kernel 6.12; the behaviour on kernels 5.13 to 6.11 was not tested.