crow-cli 0.1.34__tar.gz → 0.1.37__tar.gz

crow_cli-0.1.37/.env.example

@@ -0,0 +1,2 @@
+ZAI_API_KEY=lm-studio
+ZAI_BASE_URL=http://coast-after-3:1234/v1

crow_cli-0.1.37/.github/workflows/build-binaries.yml

@@ -0,0 +1,101 @@
+name: Build Binaries
+
+on:
+  push:
+    tags:
+      - "v*" # Trigger on version tags like v0.1.13
+
+jobs:
+  build:
+    name: Build ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os:
+          [
+            ubuntu-22.04,
+            macos-15-intel,
+            macos-latest,
+            windows-latest,
+            ubuntu-24.04-arm,
+          ]
+        include:
+          - os: ubuntu-22.04
+            target: linux-x86_64
+            archive_name: crow-cli-linux-x86_64.tar.gz
+          - os: macos-15-intel
+            target: darwin-x86_64
+            archive_name: crow-cli-darwin-x86_64.tar.gz
+          - os: macos-latest
+            target: darwin-aarch64
+            archive_name: crow-cli-darwin-aarch64.tar.gz
+          - os: windows-latest
+            target: windows-x86_64
+            archive_name: crow-cli-windows-x86_64.zip
+          - os: ubuntu-24.04-arm
+            target: linux-aarch64
+            archive_name: crow-cli-linux-aarch64.tar.gz
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: "pyproject.toml"
+
+      - name: Install dependencies
+        run: |
+          uv pip install --system pyinstaller
+
+      - name: Build with PyInstaller
+        run: |
+          uv run pyinstaller crow-cli.spec --noconfirm
+
+      - name: Create archive
+        shell: bash
+        run: |
+          cd dist
+          if [ "${{ runner.os }}" == "Windows" ]; then
+            7z a -tzip ${{ matrix.archive_name }} crow-cli.exe
+          else
+            tar -czvf ${{ matrix.archive_name }} crow-cli
+          fi
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: crow-cli-${{ matrix.target }}
+          path: ${{ matrix.archive_name }}
+          retention-days: 30
+
+  release:
+    name: Create Release
+    needs: build
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    permissions:
+      contents: write
+
+    steps:
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: crow-cli-*
+          merge-multiple: true
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: |
+            crow-cli-*.tar.gz
+            crow-cli-*.zip
+          draft: false
+          prerelease: false
+          generate_release_notes: true

crow_cli-0.1.37/.github/workflows/publish-crow-cli.yml

@@ -0,0 +1,42 @@
+name: Publish crow-cli to PyPI
+
+# Manual-only publish of the single package in this repo. Idempotent: a
+# version already live on PyPI is skipped, so a failed run can simply be
+# re-dispatched.
+on:
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/crow-cli
+    permissions:
+      id-token: write  # Required for trusted publishing
+      contents: read
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: "pyproject.toml"
+
+      - name: Build and publish (skip if already on PyPI)
+        run: |
+          set -euo pipefail
+          VERSION=$(grep -m1 '^version' pyproject.toml | sed -E 's/.*"(.*)".*/\1/')
+          if curl -fsS "https://pypi.org/pypi/crow-cli/$VERSION/json" -o /dev/null; then
+            echo "crow-cli $VERSION is already on PyPI — skipping publish"
+          else
+            uv build
+            uv publish
+          fi

crow_cli-0.1.37/.gitignore

@@ -0,0 +1,36 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# keys
+.env
+
+# test database
+*.db
+*.db*
+
+# test caches
+.pytest_cache
+config/logs/*.log
+config-done
+
+# MyST build output
+docs/_build/
+_site/
+
+crow-editor/frontend/node_modules
+
+*.log
+*.log*
+
+sandbox/lancedb-testing/pylate_lancedb/
+
+# Rust
+target/

crow_cli-0.1.37/AGENTS.md

@@ -0,0 +1,3 @@
+# RULES
+
+- Never mention the user's emotional state. I'm here to work, NOT be psychoanalyzed by a machine.

crow_cli-0.1.37/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 - present Thomas Wood
+
+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.

{crow_cli-0.1.34 → crow_cli-0.1.37}/PKG-INFO

@@ -1,28 +1,37 @@
 Metadata-Version: 2.5
 Name: crow-cli
-Version: 0.1.34
+Version: 0.1.37
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/crow-cli/crow-cli
 Project-URL: Repository, https://github.com/crow-cli/crow-cli
 Project-URL: Issues, https://github.com/crow-cli/crow-cli/issues
 Project-URL: Documentation, https://github.com/crow-cli/crow-cli#readme
+License-File: LICENSE.md
 Requires-Python: >=3.14
 Requires-Dist: agent-client-protocol[http]<0.13.0,>=0.12.0
 Requires-Dist: coolname>=2.2.0
-Requires-Dist: crow-memory==0.1.34
 Requires-Dist: directory-tree>=1.0.0
 Requires-Dist: docker>=7.2.0
-Requires-Dist: fastmcp>=2.14.5
+Requires-Dist: fastmcp>=3.4.2
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: hypercorn>=0.17
 Requires-Dist: jinja2>=3.1.6
+Requires-Dist: markdownify>=0.14.0
 Requires-Dist: openai>=2.21.0
+Requires-Dist: opencv-python>=4.13.0.92
+Requires-Dist: pydantic>=2.12.5
 Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: readabilipy>=0.3.0
 Requires-Dist: rich>=14.3.3
+Requires-Dist: sqlalchemy>=2.0
 Requires-Dist: typer>=0.24.1
 Description-Content-Type: text/markdown
 
-# crow-cli
+<p align="center">
+    <img src="https://github.com/crow-cli/crow-cli/blob/main/docs/img/crow-logo-crop.png?raw=true" alt="crow logo" width=500/>
+</p>
+
+# 🐦‍⬛ Crow
 
 <p>
   <a href="https://pypi.org/project/crow-cli/"><img src="https://img.shields.io/pypi/v/crow-cli" alt="PyPI version"></a>
@@ -55,7 +64,7 @@ Install the CLI:
 ```bash
 git clone https://github.com/crow-cli/crow-cli.git
 cd crow-cli
-uv tool install crow-cli --python 3.14      # or run without installing: uvx crow-cli --help
+uv tool install . --python 3.14      # or run without installing: uvx --from . crow-cli --help
 ```
 
 Initialize your configuration and start the backing services:
@@ -109,15 +118,13 @@ The agent detects client capabilities (terminals, file read/write) and uses the
 
 ## What's in the box
 
-crow-cli is a monorepo. The pieces:
-
-### crow-cli — the agent
+### The agent
 
-The ACP-native agent: a streaming ReAct loop with tool calling, cancellation, conversation compaction, and multimodal input. Provider and model configuration lives in `~/.agents/crow/config.yaml`.
+An ACP-native agent: a streaming ReAct loop with tool calling, cancellation, conversation compaction, and multimodal input. Provider and model configuration lives in `~/.agents/crow/config.yaml`.
 
 ### Persistence — sqlite memory
 
-Sessions persist to a single sqlite database (`~/.agents/crow/crow.db`, schema v3, WAL mode) with an FTS5 index for BM25 keyword search. Images in messages are written to `~/.agents/crow/images/` and referenced by path; they are hydrated to base64 data URLs only when the conversation is sent to the LLM. The same database backs the memory API, exposed to agents as three tools:
+Sessions persist to a single sqlite database (`~/.agents/crow/crow.db`, schema v5, WAL mode) with an FTS5 index for BM25 keyword search. Images in messages are written to `~/.agents/crow/images/` and referenced by path; they are hydrated to base64 data URLs only when the conversation is sent to the LLM. The same database backs the memory API, exposed to agents as three tools:
 
 - `list_sessions()` — sessions ordered by recent activity (who's working on what)
 - `query_memory(query)` — find which session discussed something, across all sessions
@@ -125,9 +132,9 @@ Sessions persist to a single sqlite database (`~/.agents/crow/crow.db`, schema v
 
 This is what makes multi-agent delegation work: launch a worker, then read its thoughts from any other agent. No service to run — the sqlite file is the integration point.
 
-### crow-mcp — the tool server
+### Built-in MCP tool server
 
-The built-in [MCP](https://modelcontextprotocol.io/) server providing the agent's tools:
+The bundled [MCP](https://modelcontextprotocol.io/) server (`crow-cli mcp`) providing the agent's tools:
 
 | Tool | What it does |
 |------|--------------|
@@ -139,11 +146,11 @@ The built-in [MCP](https://modelcontextprotocol.io/) server providing the agent'
 
 **Extensible by design:** register any MCP server in `~/.agents/crow/config.yaml` and its tools appear alongside these automatically.
 
-> ⚠️ **Tool names are not namespaced.** crow-mcp registers its tools as `read`, `edit`, `terminal`, … — not `crow-mcp_read`. When you add your own MCP servers, watch for name collisions.
+> ⚠️ **Tool names are not namespaced.** The built-in server registers its tools as `read`, `edit`, `terminal`, … — not `crow_read`. When you add your own MCP servers, watch for name collisions.
 
 ### SearXNG — web search
 
-crow-cli ships a maintained SearXNG configuration (stored as JSON so the agent can drive it over MCP) so web search works out of the box, without hand-editing SearXNG settings.
+crow-cli ships a maintained SearXNG configuration (stored as python so the agent works with PyInstaller — sorry) so web search works out of the box, without hand-editing SearXNG settings.
 
 ### Skills
 
@@ -169,28 +176,30 @@ models:
 ```bash
 git clone https://github.com/crow-cli/crow-cli.git
 cd crow-cli
-uv sync --project crow-cli
+uv sync
 ```
 
-Run the unit tests — fast and hermetic, no services required (unit tests that touch sessions use an in-memory fake of the persistence client; the integration tier uses a real throwaway sqlite db):
+Run the test suite — every tier runs unconditionally (unit + integration + e2e live LLM):
 
 ```bash
-uv run --project crow-cli pytest crow-cli/tests/unit
+uv run pytest tests
 ```
 
-The persistence layer itself lives in the `crow-memory` package and is tested in `crow-memory/tests/test_store.py`. Integration and end-to-end tiers are opt-in:
+The persistence layer itself lives in `src/crow_cli/memory` and is tested in `tests/memory/test_store.py`. To run a single tier, point pytest at its directory:
 
 ```bash
-uv run --project crow-cli pytest crow-cli/tests --run-integration   # spawn the agent
-uv run --project crow-cli pytest crow-cli/tests --run-e2e           # live LLM calls (costs $)
+uv run pytest tests/unit          # fast, hermetic
+uv run pytest tests/integration   # real sqlite, agent spawn
+uv run pytest tests/e2e           # live LLM calls (costs $)
 ```
 
 ## Project layout
 
 ```
-crow-cli/               the agent — ACP server, ReAct loop, CLI
-crow-mcp/               built-in MCP tool server
-crow-memory/            shared SQL persistence (sqlite default, postgres-ready)
+src/crow_cli/           the agent — ACP server, ReAct loop, CLI
+src/crow_cli/config/    config loading, defaults, overrides (shared by every layer)
+src/crow_cli/mcp/       built-in MCP tool server (`crow-cli mcp`)
+src/crow_cli/memory/    shared SQL persistence (sqlite default, postgres-ready)
 ```
 
 ## License

crow_cli-0.1.37/PLAN.md

@@ -0,0 +1,263 @@
+# PLAN — taskmaster sprint (bg-only task system)
+
+## **DO NOT ASK USER FOR FEEDBACK — THIS IS THE USER FEEDBACK.**
+## **DO NOT ASK USER FOR NEXT STEPS — THESE ARE THE NEXT STEPS.**
+
+Build/test (ALL tiers mandatory, every run):
+
+    cd /home/thomas/src/crow-team/crow-cli-taskmaster
+    uv --project . run pytest tests -q
+
+e2e uses the live model qwen3.8-max-preview (alibaba); the default
+llamacpp host coast-after-3 is DOWN. Every commit ends with the agent's
+`Session-Id:` trailer. Scope capture + the user's verbatim architecture
+quotes: TODO.md. Current trajectory: 0 → 1 → 2 → 3 → 4 → 5 → 6.
+
+One-liner: all tool calling is MCP JSON-RPC to a separate process; ACP is
+the client↔agent contract; the coupling between the two is SHARED SQLITE
+STATE, never in-process communication. Subagents are real ACP agents the
+task tool spawns as subprocesses and drives as an ACP client. Priority
+decides delivery: high = cancel→prompt, low = hold to end of prompt. No
+run_mode, no park, no hostage, no fg.
+
+---
+
+## Phase 0 — mcpServers round trip through sqlite — DONE 2026-08-23
+
+The user-designated critical path: the task tool (separate MCP server
+process) must read the parent session's client-defined mcpServers from
+sqlite to pass them through to the delegated agent.
+
+- 0.1 `session_mcp_servers` table (session_id PK, servers JSON,
+      updated_at) + `set_session_mcp_servers` / `get_session_mcp_servers`
+      in memory writes/reads. Additive — create_all picks it up, zero
+      migration drama on live dbs.
+- 0.2 `MemoryClient` async wrappers; `_mcp_servers_to_wire`
+      (model_dump(mode="json", exclude_none=True)) in agent/main.py;
+      persisted at session/new, session/load, fork_session — keyed by
+      WIRE id exactly like the in-process map. Hydration
+      (_provision_session) never overwrites the saved row.
+- 0.3 FakeMemoryClient gains the same surface (+ query_messages,
+      get_max_fork_idx the fork path needs).
+
+Verified: tests/memory/test_session_mcp_servers.py (5, incl. two-engine
+cross-process + explicit-[] toolless) and
+tests/unit/test_session_mcp_servers_wiring.py (9, incl. real ACP objects
+→ wire dicts → parse-back equality; real ACP shapes learned the hard way:
+name required, env/headers are {name,value} lists, type const explicit).
+413 fast-tier tests green.
+
+## Phase 1 — `task` tool schema prototype (FastMCP experiment) — DONE 2026-08-23
+
+EXPERIMENT FIRST: before any plumbing, prove the tool shape.
+
+- 1.1 Prototype in tests/unit: FastMCP tool `task(updates:
+      list[PromptItem | CancelTurnItem])`. PromptItem{action="prompt",
+      prompt, session_id=None, priority="low", model=None};
+      CancelTurnItem{action="cancel", session_id, prompt=None}. The two
+      item types have OVERLAPPING fields ({prompt, session_id} both
+      optional-ish) — the hypothesis is an explicit discriminator is
+      REQUIRED; prove the ambiguity fails/misparses without it and the
+      discriminated union round-trips.
+- 1.2 Dump the schema the model would see (FastMCP → tool parameters);
+      assert it names both variants and the discriminator.
+- 1.3 Call the tool through FastMCP with model-shaped args (launch,
+      re-prompt, cancel+follow-up in ONE updates list) and assert the
+      parsed pydantic objects.
+
+Verified when: the prototype tests are green and the generated schema is
+something a model can follow (eyeball it in the test output once).
+
+Verified: tests/unit/test_task_tool_schema.py — 8 green. Ambiguity proven
+(one dict validates as BOTH naive variants); discriminated union parses
+launch/re-prompt/cancel+follow-up; omitted action REJECTED (pydantic
+discriminator is strict — the model must state intent, the schema marks
+action const per variant); model-visible schema names PromptItem +
+CancelTurn + action + high/low; mixed batch round-trips through the real
+FastMCP call path; unknown action rejected, not guessed.
+
+## Phase 2 — task state in sqlite — DONE 2026-08-23
+
+- 2.1 `tasks` + `task_deliveries` tables (additive v5): see TODO.md for
+      columns. deliveries = durable mailbox; status pending|delivered.
+- 2.2 memory reads/writes: launch_task / finish_task (STATE FIRST:
+      update tasks row + insert delivery in ONE commit) /
+      pending_deliveries / mark_delivered / task_by_id / running_tasks.
+- 2.3 Cross-process test: writer engine finishes a task, reader engine
+      sees the delivery (the MCP-server-process / agent-process split).
+
+Verified when: unit tests green incl. the two-engine case and idempotent
+double-finish (a second finish on a terminal task is a no-op).
+
+Verified: tests/memory/test_task_state.py — 7 green: launch registers
+running state cross-engine; finish flips status AND lands the delivery in
+ONE commit (read back through a second engine); double-finish no-op;
+unknown-task no-op; mark_delivered drains in arrival order; priority rides
+both rows; mailboxes per-session.
+
+## Phase 3 — client driver + task tool + live e2e — DONE 2026-08-23
+
+Placement (user-corrected, verbatim): "IT PROBABLY SHOULD BE SPLIT
+INTELLIGENTLY BETWEEN CLIENT AND MCP" — client package owns the ACP
+machinery (headless, no state knowledge), mcp package owns the `task`
+tool (schema + sqlite coupling + dispatch), agent package gets NOTHING
+new. The two couple through sqlite, never in-process.
+
+- 3.1 WAKE EXPERIMENT — DONE (de4e6596): `_run_internal_round` in
+      agent/main.py, synthetic round with NO client request; live-model
+      e2e green (tests/e2e/test_wake_experiment.py). Race sentinel
+      converted (150s, expects the hang) — flips into the regression at
+      Phase 6.1.
+- 3.2a CLIENT DRIVER — DONE (b139549e): src/crow_cli/client/subagent.py —
+      spawn_agent_process() free fn, HeadlessClient (swallows updates;
+      fs/permission = method_not_found), SubagentDriver (start/
+      new_session/load_session/prompt/cancel/close; terminal=False at
+      handshake). CrowClient.spawn_agent delegates to the shared spawn
+      fn — one spawn path.
+- 3.2b THE TASK TOOL — DONE (a6211824): src/crow_cli/mcp/task/main.py —
+      ONE `task` tool, `updates: list[PromptItem | CancelTurn]`
+      discriminated on action (Phase 1 models promoted). Launch: STATE
+      FIRST → driver start → session/new with the OWNER's mcpServers
+      passthrough (Phase 0 round trip consumed) → watcher. Re-prompt:
+      live mid-turn refuses; terminal row reopens + session/load (the
+      agent implements load, NOT resume). Cancel: driver.cancel() →
+      pending prompt resolves cancelled; optional follow-up reopens the
+      row and the watcher loop continues. New state fns:
+      set_task_sub_session, reopen_task, task_by_sub_session,
+      count_tasks (task-N numbering). Owner attribution: the agent
+      intercepts tool_name == "task" and passes the calling session's
+      wire id through the tools/call _meta — execute_acp_task +
+      task(updates, ctx: Context), Context filtered out of the LLM
+      schema (be2317db; replaced env injection, which was a hack).
+      Config context for children still rides CROW_CONFIG_FILE/
+      CROW_CONFIG_DIR process env. Registered in server/main.py.
+- 3.3 LIVE E2E — DONE (6d9316aa): tests/e2e/test_task_mcp_launch.py —
+      launch→completion (answer lands in the delivery), mcpServers
+      passthrough (child USES the passed-through terminal tool: date
+      output in its answer — [] cascade stays dead), cancel mid-turn,
+      cancel→follow-up (one delivery, follow-up answered). Isolation =
+      production shape: CROW_DB_URI for the tool, CROW_CONFIG_FILE
+      (same tmp db) for the child.
+- 3.4 CRASH PATH — DONE (this commit): SIGKILL the child mid-turn →
+      watcher's prompt future breaks on the dead transport → failed
+      status + delivery, never hangs (test_child_crash_registers_failed).
+
+Found en route (3.3): the SDK SILENTLY DROPS mcpServers request items
+that fail validation (a stdio dict missing the required env list
+vanished; the child came up toolless with no error anywhere). The driver
+now parses wire dicts item-by-item BEFORE sending (_parse_mcp_servers —
+loud failures, fills required-but-emptyable args/env); pinned by
+tests/unit/test_subagent_parse_servers.py. Also observed: a child that
+still carries DELEGATE_TOOL may delegate instead of using its
+passed-through tools — structurally resolved by Phase 5.3's deletion.
+
+## Phase 4 — react loop: kill the hostage machinery, consult state — DONE 2026-08-23
+
+The loop CONSULTS STATE at natural breakpoints — no polling in-loop, no
+parking, no hostage. Completions register in sqlite (finish_task lands
+them in task_deliveries the moment they arrive); the loop looks at the
+mailbox at three points and the quiescent watcher covers the fourth.
+
+- 4.1 DONE. park_until_completion, wake queues, drain_dead,
+      synthetic_completion_message, cancel_all propagation — all gone
+      from react.py. End-turn check: consult_deliveries() claims ALL
+      pending deliveries → inject as synthetic user messages + loop
+      continues; none → end_turn.
+- 4.2 DONE. Prompt-start drain: consult_deliveries() before the first
+      model call — idle arrivals are known at prompt start.
+- 4.3 DONE (breakpoint form). After each tool batch:
+      consult_deliveries(high_only=True) — highs inject at the next
+      batch boundary, lows stay pending for end of turn. Cancelling a
+      mid-STREAM model response would need polling in the streaming
+      loop (rejected), so the batch boundary is the earliest injection
+      point; a high that lands while the session is idle wakes it at
+      once via the watcher (below).
+- 4.4 DONE. Parent cancel does NOT touch children — the react loop's
+      CancelledError handler persists history and re-raises; subagents
+      keep running, their completions still land in the mailbox, and
+      the model cancels them itself via task(CancelTurn) if it wants.
+- 4.5 DONE (the out-of-loop half). AcpAgent._delivery_watcher: one
+      asyncio task per session (started at provisioning, cancelled at
+      cleanup), polls every DELIVERY_POLL_S=2s. Session lock held
+      (active turn) → skip, the in-loop consults own that window.
+      Idle + pending → atomic claim, then _run_internal_round with the
+      joined delivery contents (Phase 3.1's wake). The claim is a
+      single UPDATE...RETURNING (claim_deliveries in memory/writes.py):
+      watcher vs in-loop consult can race for the same rows and each
+      delivery is still injected EXACTLY ONCE.
+
+Verified when: integration tests cover all three arrival states
+(active-low, active-high, idle) with a controllable child; the old
+park/wake tests are deleted, not adapted.
+Evidence: tests/integration/test_react_loop_tool_round.py
+(test_prompt_start_drains_idle_mailbox,
+test_low_delivery_held_to_end_of_turn — real sqlite mailbox, scripted
+LLM, real react_loop), tests/unit/test_delivery_watcher.py (wake,
+skip-while-active, idempotent ensure, no double claim),
+tests/memory/test_task_state.py (claim_deliveries: arrival order,
+priority filter, cross-engine no-double-claim). 418 passed in the fast
+tiers at this commit.
+
+## Phase 5 — kill delegate.py — DONE 2026-08-23
+
+(The `task` tool shipped in Phase 3.2b and its session-context channel
+shipped with be2317db: owner attribution rides the tools/call _meta,
+injected by execute_acp_task in the react loop — the LLM never sees it
+and cannot forge it. What remains is deleting the machinery `task`
+replaces.)
+
+- 5.1 DONE. DELETED src/crow_cli/agent/delegate.py and
+      src/crow_cli/agent/tasks.py; DELEGATE_TOOL imports, the
+      TaskRegistry, the _session_mcp_servers in-process map (sqlite's
+      session_mcp_servers row stays the cross-process authority), and
+      the registry/session_mcp_servers kwargs from react_loop +
+      execute_tool_calls + both react_loop call sites in agent/main.py.
+      Tests deleted: unit/test_delegate.py, unit/test_tasks.py,
+      e2e/test_delegate_live.py, e2e/test_delegate_true_e2e.py.
+- 5.2 DONE (no rewrite needed). The model-facing recipe was
+      DELEGATE_TOOL.description itself — it died with the file. The
+      `task` tool's own description in mcp/task/main.py is the recipe
+      now (launch = PromptItem no session_id; re-prompt = PromptItem
+      with session_id; cancel = CancelTurn, optional follow-up). No
+      system prompt carried a delegation section (checked
+      config/default/defaults.py's SYSTEM_PROMPT and the user's live
+      ~/.agents/crow/prompts/system_prompt.jinja2). CLI help text
+      updated: agents launch subagents via `task`; `run -s` is the
+      human attach recipe.
+
+Verified when: rg "delegate" finds no live code path; an agent with
+crow-mcp launches a subagent through `task` with zero delegate code.
+Evidence: rg delegate over src/ matches only docstrings/comments
+(models.py task-table history note, mcp/memory tool descriptions,
+mcp/task module docstring, mcp/editor "delegated to the OS"); zero
+imports of the deleted modules anywhere.
+
+## Phase 6 — regression + live E2E + full suite — DONE 2026-08-23
+
+- 6.1 DONE. tests/e2e/test_delegate_race_experiment.py (the sentinel that
+      asserted the hang) rewritten + renamed
+      tests/e2e/test_task_race_regression.py: fast child completes
+      mid-parent-turn → registered in state → delivered (low: end-turn
+      injection) → end_turn fires. The hang is structurally impossible:
+      nothing waits on unregistered work. GREEN live (90s) against
+      qwen3.8-max-preview. Two e2e isolation lessons baked into it:
+      (a) the ACP SDK SILENTLY DROPS mcpServers items that fail schema
+      validation — stdio needs name/command/args AND env (a list of
+      {name,value}); (b) the mcp stdio spawn gives the child ONLY
+      {**get_default_environment(), **server.env} — NOTHING is inherited
+      from the agent process, so db/config isolation must ride the wire
+      env (CROW_DB_URI / CROW_CONFIG_FILE), which the task tool then
+      forwards to the child it launches.
+- 6.2 DONE. test_task_mcp_launch.py::
+      test_two_subagents_high_and_low_both_deliver — one `task` call
+      launches two subagents (high + low), both complete, both
+      deliveries land with their priorities (live, 12s). The loop-side
+      priority routing (high at batch boundary, low held to end-turn)
+      is covered by the integration consult tests; cancel mid-flight by
+      test_cancel_mid_turn / test_cancel_with_follow_up.
+- 6.3 DONE. `uv --project . run pytest tests -q` from the worktree
+      root: 432 passed, 0 failed, 0 skipped (167s, 2026-08-23). The
+      merge to main is the user's call.
+
+Verified when: `uv --project . run pytest tests -q` is all-green, zero
+skipped, from a clean checkout of the branch.