blitz-cli 0.10.0__tar.gz → 0.11.0__tar.gz

{blitz_cli-0.10.0 → blitz_cli-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blitz-cli
-Version: 0.10.0
+Version: 0.11.0
 Summary: Developer CLI for Blitz locker-room: spec-driven playbooks, a codebase/huddle ontology graph with an MCP tool, and the composable watcher/trainer/graph containers.
 License: MIT
 License-File: LICENSE
@@ -31,7 +31,7 @@ The core CLI is stdlib plus `rich`. Two optional extras carry heavier deps only
 when you need them: `blitz-cli[locker-room]` (the MCP server) and
 `blitz-cli[train]` (the QLoRA trainer).
 
-Top-level commands: `init`, `implement`, `locker-room`.
+Top-level commands: `init`, `model`, `locker-room`.
 
 ## Playbooks: spec-driven development commands
 
@@ -51,9 +51,9 @@ and `analyze`. Run at a folder of repos, `init` installs into each repo it finds
 for coordinating a feature across repos. Use `--ignore PATH` to skip a repo and
 `--root` to force a single install.
 
-## Implement: execute a tasks.md with a local model
+## Model execute: run a tasks.md with a local model
 
-`blitz implement` drives a local model (served by Ollama) through a
+`blitz model execute` drives a local model (served by Ollama) through a
 playbook-generated `tasks.md`, one task at a time. The model only proposes
 actions (full-file writes and shell commands); the driver applies them, runs
 each phase's machine-runnable verification, retries with the failure fed back
@@ -61,17 +61,17 @@ each phase's machine-runnable verification, retries with the failure fed back
 `- [x]` in the tasks.md. A task that keeps failing stops the run so the state
 stays inspectable. Per-attempt model replies, snapshots, and exact token
 accounting (`usage.json`, per task and total) land under
-`.blitz/implement/runs/<timestamp>/`.
+`.blitz/execute/runs/<timestamp>/`.
 
 ```bash
-blitz implement                                   # auto-detect the open specs/*/tasks.md
-blitz implement specs/001-my-feature/tasks.md     # or name it
-blitz implement --model qwen2.5-14b-28k --start-at T005
+blitz model execute                                   # auto-detect the open specs/*/tasks.md
+blitz model execute specs/001-my-feature/tasks.md     # or name it
+blitz model execute --model qwen2.5-14b-28k --start-at T005
 ```
 
 Tasks whose text says "optional manual" are skipped and left unchecked. The
 Ollama endpoint comes from `--ollama-url` or `OLLAMA_HOST`; the model from
-`--model` or `BLITZ_IMPLEMENT_MODEL`.
+`--model` or `BLITZ_EXECUTE_MODEL`.
 
 ## Locker-room: ontology graph, watcher, trainer, MCP
 

{blitz_cli-0.10.0 → blitz_cli-0.11.0}/README.md

@@ -12,7 +12,7 @@ The core CLI is stdlib plus `rich`. Two optional extras carry heavier deps only
 when you need them: `blitz-cli[locker-room]` (the MCP server) and
 `blitz-cli[train]` (the QLoRA trainer).
 
-Top-level commands: `init`, `implement`, `locker-room`.
+Top-level commands: `init`, `model`, `locker-room`.
 
 ## Playbooks: spec-driven development commands
 
@@ -32,9 +32,9 @@ and `analyze`. Run at a folder of repos, `init` installs into each repo it finds
 for coordinating a feature across repos. Use `--ignore PATH` to skip a repo and
 `--root` to force a single install.
 
-## Implement: execute a tasks.md with a local model
+## Model execute: run a tasks.md with a local model
 
-`blitz implement` drives a local model (served by Ollama) through a
+`blitz model execute` drives a local model (served by Ollama) through a
 playbook-generated `tasks.md`, one task at a time. The model only proposes
 actions (full-file writes and shell commands); the driver applies them, runs
 each phase's machine-runnable verification, retries with the failure fed back
@@ -42,17 +42,17 @@ each phase's machine-runnable verification, retries with the failure fed back
 `- [x]` in the tasks.md. A task that keeps failing stops the run so the state
 stays inspectable. Per-attempt model replies, snapshots, and exact token
 accounting (`usage.json`, per task and total) land under
-`.blitz/implement/runs/<timestamp>/`.
+`.blitz/execute/runs/<timestamp>/`.
 
 ```bash
-blitz implement                                   # auto-detect the open specs/*/tasks.md
-blitz implement specs/001-my-feature/tasks.md     # or name it
-blitz implement --model qwen2.5-14b-28k --start-at T005
+blitz model execute                                   # auto-detect the open specs/*/tasks.md
+blitz model execute specs/001-my-feature/tasks.md     # or name it
+blitz model execute --model qwen2.5-14b-28k --start-at T005
 ```
 
 Tasks whose text says "optional manual" are skipped and left unchecked. The
 Ollama endpoint comes from `--ollama-url` or `OLLAMA_HOST`; the model from
-`--model` or `BLITZ_IMPLEMENT_MODEL`.
+`--model` or `BLITZ_EXECUTE_MODEL`.
 
 ## Locker-room: ontology graph, watcher, trainer, MCP
 

{blitz_cli-0.10.0 → blitz_cli-0.11.0}/blitz_cli/__init__.py

@@ -30,4 +30,4 @@ Commands:
 
 __all__ = ["__version__"]
 
-__version__ = "0.10.0"
+__version__ = "0.11.0"

blitz_cli-0.10.0/blitz_cli/_implement.py → blitz_cli-0.11.0/blitz_cli/_execute.py

@@ -1,6 +1,6 @@
 """Drive a local model (served by Ollama) through a playbook-generated
 tasks.md, one task at a time — the local-model execution backend for the
-`implement` playbook.
+`blitz model execute` command.
 
 The model never touches the repo directly: it only proposes actions
 (full-file ===WRITE=== blocks and ===RUN=== commands) and this driver applies
@@ -237,12 +237,12 @@ def local_model_config(repo: Path) -> dict:
 
 
 def usage_by_spec(repo: Path) -> dict:
-    """Aggregate every implement run's usage.json under
-    .blitz/implement/runs/, keyed by spec: total input/output tokens, model
+    """Aggregate every execute run's usage.json under
+    .blitz/execute/runs/, keyed by spec: total input/output tokens, model
     calls, run count, and the models used. This is what the locker-room
     ontologizer attaches to Feature nodes so the UI can show per-spec cost."""
     totals: dict = {}
-    for f in sorted(repo.glob(".blitz/implement/runs/*/usage.json")):
+    for f in sorted(repo.glob(".blitz/execute/runs/*/usage.json")):
         try:
             record = json.loads(f.read_text())
         except (OSError, ValueError):
@@ -289,7 +289,7 @@ def run(
     """Execute every unchecked task in tasks_file. Returns 0 on success, 1 when a
     task fails after all retries (the run stops there so state stays inspectable)."""
     call_model = call_model or (lambda messages: call_ollama(ollama_url, model, messages))
-    run_root = run_root or (repo / ".blitz" / "implement" / "runs")
+    run_root = run_root or (repo / ".blitz" / "execute" / "runs")
     rundir = run_root / datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
     snapdir = rundir / "snapshots"
     snapdir.mkdir(parents=True, exist_ok=True)

{blitz_cli-0.10.0 → blitz_cli-0.11.0}/blitz_cli/_ontology.py

@@ -16,7 +16,7 @@ import re
 import sqlite3
 from pathlib import Path
 
-from blitz_cli import _activity, _implement, _playbooks
+from blitz_cli import _activity, _execute, _playbooks
 
 # --- graph store -------------------------------------------------------------
 
@@ -349,10 +349,10 @@ def _read_active_feature(repo: Path) -> str | None:
 
 def _tasks_complete(tasks_md: Path) -> bool:
     """True when every required task in a tasks.md is checked off. Tasks whose
-    text says "optional manual" don't count against completion (the implement
+    text says "optional manual" don't count against completion (the execute
     driver skips them by design)."""
     try:
-        tasks, _ = _implement.parse_tasks(tasks_md.read_text(encoding="utf-8"))
+        tasks, _ = _execute.parse_tasks(tasks_md.read_text(encoding="utf-8"))
     except OSError:
         return False
     required = [t for t in tasks if "optional manual" not in t["body"].lower()]
@@ -527,7 +527,7 @@ def ontologize(workspace_root, db_path, ignore=None, code=True,
             _code_graph.scan_repo(store, repo, rid, max_file_bytes=max_file_bytes)
 
         active = _read_active_feature(repo)
-        usage = _implement.usage_by_spec(repo)
+        usage = _execute.usage_by_spec(repo)
         specs = repo / "specs"
         if specs.is_dir():
             for feat in sorted(specs.iterdir()):

{blitz_cli-0.10.0 → blitz_cli-0.11.0}/blitz_cli/cli.py

@@ -59,8 +59,8 @@ def _cmd_locker_room_make(args: argparse.Namespace) -> int:
 
 
 
-def _cmd_implement(args: argparse.Namespace) -> int:
-    from blitz_cli import _implement
+def _cmd_execute(args: argparse.Namespace) -> int:
+    from blitz_cli import _execute
 
     repo = Path(args.repo).resolve()
     if args.tasks:
@@ -68,7 +68,7 @@ def _cmd_implement(args: argparse.Namespace) -> int:
         if not tasks_file.is_absolute():
             tasks_file = repo / tasks_file
     else:
-        tasks_file = _implement.find_tasks_file(repo)
+        tasks_file = _execute.find_tasks_file(repo)
         if tasks_file is None:
             _eprint(
                 f"error: could not auto-detect a unique specs/*/tasks.md with "
@@ -80,16 +80,16 @@ def _cmd_implement(args: argparse.Namespace) -> int:
         _eprint(f"error: no tasks file at {tasks_file}.")
         return 2
 
-    # Model resolution: --model flag > BLITZ_IMPLEMENT_MODEL env >
+    # Model resolution: --model flag > BLITZ_EXECUTE_MODEL env >
     # .blitz/config.json local_model.model (repo, then workspace) > default.
     model = (
         args.model
-        or os.environ.get("BLITZ_IMPLEMENT_MODEL")
-        or _implement.local_model_config(repo).get("model")
-        or _implement.DEFAULT_MODEL
+        or os.environ.get("BLITZ_EXECUTE_MODEL")
+        or _execute.local_model_config(repo).get("model")
+        or _execute.DEFAULT_MODEL
     )
 
-    return _implement.run(
+    return _execute.run(
         repo=repo,
         tasks_file=tasks_file,
         model=model,
@@ -290,48 +290,54 @@ def build_parser() -> argparse.ArgumentParser:
     sub = parser.add_subparsers(dest="cmd", required=True)
 
 
-    impl = sub.add_parser(
-        "implement",
+    model = sub.add_parser(
+        "model",
+        help="Model lifecycle commands (e.g. execute a tasks.md with a local model).",
+    )
+    model_sub = model.add_subparsers(dest="model_cmd", required=True)
+
+    execute = model_sub.add_parser(
+        "execute",
         help="Execute a playbook-generated tasks.md with a local model served by "
         "Ollama: one task per call, driver-side verification, bounded retries, "
-        "snapshots under .blitz/implement/runs/.",
+        "snapshots under .blitz/execute/runs/.",
     )
-    impl.add_argument(
+    execute.add_argument(
         "tasks", nargs="?", default=None,
         help="Path to the tasks.md (relative to --repo). Default: the unique "
         "specs/*/tasks.md that still has unchecked tasks.",
     )
-    impl.add_argument(
+    execute.add_argument(
         "--repo", default=".", help="Repo root the tasks operate on (default: current dir)."
     )
-    impl.add_argument(
+    execute.add_argument(
         "--model",
         default=None,
         help="Ollama model to drive. Default resolution: this flag, then "
-        "BLITZ_IMPLEMENT_MODEL, then local_model.model in .blitz/config.json "
+        "BLITZ_EXECUTE_MODEL, then local_model.model in .blitz/config.json "
         "(repo, then workspace), then qwen2.5-14b-28k.",
     )
-    impl.add_argument(
+    execute.add_argument(
         "--local-only", action="store_true",
         help="Execute only tasks marked [L] (local-model eligible), stopping at "
         "the first unchecked task without the marker so an orchestrating agent "
         "can take over. Used to split a tasks.md between the local model and a "
         "frontier agent.",
     )
-    impl.add_argument(
+    execute.add_argument(
         "--ollama-url",
         default=os.environ.get("OLLAMA_HOST", "http://localhost:11434"),
         help="Ollama base URL (default http://localhost:11434; env OLLAMA_HOST).",
     )
-    impl.add_argument(
+    execute.add_argument(
         "--max-retries", type=int, default=2,
         help="Retries per task with the failure fed back before stopping the run (default 2).",
     )
-    impl.add_argument(
+    execute.add_argument(
         "--start-at", default=None, metavar="TASK_ID",
         help="Skip ahead to this task id (e.g. T005) before executing.",
     )
-    impl.set_defaults(func=_cmd_implement)
+    execute.set_defaults(func=_cmd_execute)
 
     sp_init = sub.add_parser(
         "init",

{blitz_cli-0.10.0 → blitz_cli-0.11.0}/blitz_cli/playbooks/commands/implement.md

@@ -151,15 +151,15 @@ You **MUST** consider the user input before proceeding (if not empty).
      that is the point of the marker: the user is paying for frontier tokens only where needed.
    - Work through the task list in ID order with this loop:
      1. Find the next unchecked, non-"optional manual" task.
-     2. If it is marked `[L]`: run `blitz implement <path-to-tasks.md> --local-only --start-at <TaskID>`
+     2. If it is marked `[L]`: run `blitz model execute <path-to-tasks.md> --local-only --start-at <TaskID>`
         and wait. The command executes the contiguous run of `[L]` tasks, checks them off in
         tasks.md, and exits 0 when it reaches a task without the marker (or finishes).
         Exit 1 means a local task failed after retries — take that task over yourself
-        (its per-attempt replies are in `.blitz/implement/runs/<stamp>/`), mark it off,
+        (its per-attempt replies are in `.blitz/execute/runs/<stamp>/`), mark it off,
         then resume the loop.
      3. If it is NOT marked `[L]`: execute it yourself as described below, mark it off,
         and resume the loop.
-     4. After every `blitz implement` invocation, RE-READ tasks.md — the file changed on disk.
+     4. After every `blitz model execute` invocation, RE-READ tasks.md — the file changed on disk.
    - Never execute an `[L]` task yourself while the CLI is available unless it has already
      failed a local run.
 

{blitz_cli-0.10.0 → blitz_cli-0.11.0}/blitz_cli/playbooks/commands/tasks.md

@@ -206,7 +206,7 @@ files that are exactly specified and unforgiving of drift.
 ### Executor Annotation ([L] marker)
 
 Task lists can be executed by a mix of a frontier agent and the user's own local model (via
-`blitz implement --local-only`). Whether a local model is available — and what it can handle —
+`blitz model execute --local-only`). Whether a local model is available — and what it can handle —
 is configured, not guessed:
 
 1. Read `.blitz/config.json` in the repo root. If it has no `local_model` key, read
@@ -240,7 +240,7 @@ is configured, not guessed:
 
 4. Place `[L]` after `[P]` and before the `[Story]` label:
    `- [ ] T003 [P] [L] [US1] CREATE ...`
-5. The marker is load-bearing and machine-parsed: `blitz implement --local-only` executes
+5. The marker is load-bearing and machine-parsed: `blitz model execute --local-only` executes
    consecutive `[L]` tasks and stops at the first task without the marker, handing control back
    to the orchestrating agent. Keep runs of local-eligible tasks contiguous where dependencies
    allow — interleaving one frontier task between local ones forces a round-trip per task.

{blitz_cli-0.10.0 → blitz_cli-0.11.0}/blitz_cli/templates/workspace_playbook.md.tmpl

@@ -21,7 +21,7 @@ and what code a feature touches via lineage queries.
 ## Executor routing
 
 `.blitz/config.json` may define a `local_model`. Tasks marked `[L]` in a
-tasks.md are executable by that model via `blitz implement --local-only`;
+tasks.md are executable by that model via `blitz model execute --local-only`;
 frontier agents handle the rest. See the /implement command for the handoff
 loop.
 

{blitz_cli-0.10.0 → blitz_cli-0.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "blitz-cli"
-version = "0.10.0"
+version = "0.11.0"
 description = "Developer CLI for Blitz locker-room: spec-driven playbooks, a codebase/huddle ontology graph with an MCP tool, and the composable watcher/trainer/graph containers."
 readme = "README.md"
 license = { text = "MIT" }

blitz_cli-0.11.0/specs/001-cli-model-namespace/checklists/requirements.md

@@ -0,0 +1,34 @@
+# Specification Quality Checklist: CLI model namespace (retire "implement")
+
+**Purpose**: Validate specification completeness and quality before proceeding to planning
+**Created**: 2026-07-14
+**Feature**: [spec.md](../spec.md)
+
+## Content Quality
+
+- [x] No implementation details (languages, frameworks, APIs)
+- [x] Focused on user value and business needs
+- [x] Written for non-technical stakeholders
+- [x] All mandatory sections completed
+
+## Requirement Completeness
+
+- [x] No [NEEDS CLARIFICATION] markers remain
+- [x] Requirements are testable and unambiguous
+- [x] Success criteria are measurable
+- [x] Success criteria are technology-agnostic (no implementation details)
+- [x] All acceptance scenarios are defined
+- [x] Edge cases are identified
+- [x] Scope is clearly bounded
+- [x] Dependencies and assumptions identified
+
+## Feature Readiness
+
+- [x] All functional requirements have clear acceptance criteria
+- [x] User scenarios cover primary flows
+- [x] Feature meets measurable outcomes defined in Success Criteria
+- [x] No implementation details leak into specification
+
+## Notes
+
+- Hard-rename decision resolved with the user; no open clarifications. Spec ready for `/plan`.

blitz_cli-0.11.0/specs/001-cli-model-namespace/contracts/cli-commands.md

@@ -0,0 +1,47 @@
+# CLI Command Surface Contract
+
+## Before
+
+```
+blitz implement [tasks] [--repo DIR] [--model M] [--local-only]
+                [--ollama-url URL] [--max-retries N] [--start-at TASK_ID]
+```
+
+## After
+
+```
+blitz model execute [tasks] [--repo DIR] [--model M] [--local-only]
+                    [--ollama-url URL] [--max-retries N] [--start-at TASK_ID]
+```
+
+- `blitz model` (no subcommand) → prints `model` group help, exits non-zero (subparser `required=True`).
+- `blitz model execute …` → identical arguments, defaults, behavior, and exit codes as the former `blitz implement`. Handler: `_cmd_execute`.
+- `blitz --help` → lists `model`; does NOT list `implement`.
+- `blitz model --help` → lists `execute` with the help text formerly on `implement`.
+- `blitz implement …` → **removed**. Argparse default "invalid choice: 'implement'" error, non-zero exit. No stub, no forwarding.
+
+## Arguments carried onto `execute` (unchanged)
+
+| Arg | Type | Default |
+|-----|------|---------|
+| `tasks` | positional, optional | None (auto-detect open `specs/*/tasks.md`) |
+| `--repo` | str | `.` |
+| `--model` | str | None (resolves via flag → `BLITZ_EXECUTE_MODEL` → config → `qwen2.5-14b-28k`) |
+| `--local-only` | flag | False |
+| `--ollama-url` | str | `$OLLAMA_HOST` or `http://localhost:11434` |
+| `--max-retries` | int | 2 |
+| `--start-at` | str (TASK_ID) | None |
+
+## Renamed identifiers (breaking, no migration)
+
+| Old | New |
+|-----|-----|
+| env `BLITZ_IMPLEMENT_MODEL` | env `BLITZ_EXECUTE_MODEL` |
+| path `.blitz/implement/runs/` | path `.blitz/execute/runs/` |
+| module `blitz_cli/_implement.py` | module `blitz_cli/_execute.py` |
+| handler `_cmd_implement` | handler `_cmd_execute` |
+| test `tests/test_implement.py` | test `tests/test_execute.py` |
+
+## Not changed
+
+The `/implement` playbook SDD slash-command, the `"implemented"` lifecycle stage, and generic "implementation" prose are out of scope.

blitz_cli-0.11.0/specs/001-cli-model-namespace/plan.md

@@ -0,0 +1,73 @@
+# Implementation Plan: CLI model namespace (retire "implement")
+
+**Branch**: `001-cli-model-namespace` | **Date**: 2026-07-14 | **Spec**: [spec.md](./spec.md)
+
+**Input**: Feature specification from `specs/001-cli-model-namespace/spec.md`
+
+## Summary
+
+Move the top-level `blitz implement` subcommand under a new `model` command group and rename it to `execute` (`blitz model execute`), and purge the "implement" nomenclature that names this command. The engine behavior is reused unchanged, but the module, handler, env var, and run-snapshot path are all renamed to "execute". The old `blitz implement` is removed outright (no error stub) — argparse reports an invalid choice. This is a breaking change with no migration of existing `.blitz/implement/runs/` snapshots or `BLITZ_IMPLEMENT_MODEL` settings.
+
+Out of scope (distinct concept, NOT renamed): the `/implement` playbook SDD slash-command and its `__SPECKIT_COMMAND_IMPLEMENT__` token; the `"implemented"` feature lifecycle stage in `_ontology.py`; generic "implementation" prose.
+
+## Technical Context
+
+**Language/Version**: Python 3 (stdlib + `rich`); `argparse` CLI.
+**Primary Dependencies**: stdlib `argparse`; no new deps.
+**Storage**: On-disk run snapshots move `.blitz/implement/runs/` → `.blitz/execute/runs/` (breaking, no migration).
+**Testing**: `pytest`; `tests/test_implement.py` → `tests/test_execute.py`; plus `tests/test_cli.py`, `tests/test_ontology.py`.
+**Target Platform**: Local developer machines (pip-installed CLI).
+**Project Type**: Single-project CLI (`blitz_cli/`).
+**Performance Goals**: N/A (rename/refactor).
+**Constraints**: Backward-incompatible by design; no compatibility shims.
+**Scale/Scope**: One subparser relocation+rename, module/handler/env/path rename across ~4 source files + tests + docs.
+
+## Playbook Check
+
+`.blitz/memory/playbook.md` is the unfilled template — no concrete gates. PASS.
+
+## Project Structure
+
+### Documentation (this feature)
+
+```text
+specs/001-cli-model-namespace/
+├── plan.md · research.md · quickstart.md
+├── contracts/cli-commands.md
+├── checklists/requirements.md
+└── tasks.md
+```
+
+(No data-model.md — no entities.)
+
+### Source Code — files touched
+
+```text
+blitz_cli/
+├── cli.py          # EDIT: build_parser() — replace top-level `implement` parser with
+│                   #   `model` group + `execute` child; rename _cmd_implement → _cmd_execute;
+│                   #   import _execute; read BLITZ_EXECUTE_MODEL; update help text
+├── _implement.py   # RENAME → _execute.py; update `.blitz/implement/runs` → `.blitz/execute/runs`
+│                   #   (lines ~240,241,245,292) and the module docstring
+├── _ontology.py    # EDIT: import _execute (was _implement); `.blitz/implement/runs` → `.blitz/execute/runs`
+│                   #   at line ~68-equivalent usage; KEEP "implemented" stage + prose
+README.md           # EDIT: command list, examples, BLITZ_IMPLEMENT_MODEL → BLITZ_EXECUTE_MODEL,
+│                   #   `.blitz/implement/runs` → `.blitz/execute/runs`
+blitz_cli/playbooks/commands/implement.md   # EDIT: `blitz implement … --local-only` → `blitz model execute …`
+blitz_cli/playbooks/commands/tasks.md       # EDIT: same CLI-ref update
+blitz_cli/templates/workspace_playbook.md.tmpl  # EDIT: same CLI-ref update
+tests/test_implement.py  # RENAME → tests/test_execute.py; `_implement` → `_execute`; path updates
+tests/test_cli.py        # EDIT/ADD: assert `model execute` wired; `implement` absent
+tests/test_ontology.py   # EDIT: `.blitz/implement/runs` → `.blitz/execute/runs` (line ~68); test name optional
+```
+
+**Structure Decision**: Single-project CLI; `model` group follows the `locker-room` nested-subparser pattern. `execute` carries the identical argument set and `func=_cmd_execute`.
+
+## Complexity Tracking
+
+No playbook violations.
+
+## Phases
+
+- **Phase 0 (research.md)**: decisions recorded — hard rename (no stub), nested `model` group, full nomenclature purge (breaking), out-of-scope list, playbook-ref updates.
+- **Phase 1 (contracts/, quickstart.md)**: command surface + renamed-identifier table; runnable validation incl. a grep for stray nomenclature. No data-model.md.

blitz_cli-0.11.0/specs/001-cli-model-namespace/quickstart.md

@@ -0,0 +1,37 @@
+# Quickstart / Validation: model namespace
+
+Prerequisites: editable install of blitz-cli (`pip install -e .`) or run via `python -m blitz_cli`.
+
+## Validate the new surface
+
+```bash
+blitz --help                 # expect: `model` listed; `implement` NOT listed
+blitz model --help           # expect: `execute` subcommand listed
+blitz model execute --help   # expect: same flags as the old `blitz implement --help`
+```
+
+## Validate the old command is gone
+
+```bash
+blitz implement ; echo "exit=$?"   # expect: argparse "invalid choice: 'implement'"; exit != 0
+```
+
+## Validate behavior parity + renamed path/env
+
+Run `blitz model execute` against a spec's tasks.md as before; confirm identical driver behavior and that snapshots are written under `.blitz/execute/runs/` (not `.blitz/implement/runs/`). Confirm `BLITZ_EXECUTE_MODEL` selects the model.
+
+## No stray nomenclature
+
+```bash
+grep -rnE "blitz implement|BLITZ_IMPLEMENT_MODEL|\.blitz/implement/runs|_cmd_implement|_implement" \
+  blitz_cli README.md tests
+# expect: no matches (out-of-scope /implement slash-command & "implemented" stage excluded from this pattern set)
+```
+
+## Test suite
+
+```bash
+pytest -q          # expect: all pass, including renamed tests/test_execute.py
+```
+
+Contract reference: [contracts/cli-commands.md](./contracts/cli-commands.md).

blitz_cli-0.11.0/specs/001-cli-model-namespace/research.md

@@ -0,0 +1,34 @@
+# Research: CLI model namespace (retire "implement")
+
+## Decision 1 — Hard rename, no error stub
+
+- **Decision**: Delete the `implement` parser entirely. `blitz implement` produces argparse's default "invalid choice" error and non-zero exit.
+- **Rationale**: User explicitly does not want an error stub forwarding to `model execute`. Simplest surface; no dangling "implement" reference.
+- **Alternatives considered**: Error stub naming the replacement — rejected by user.
+
+## Decision 2 — `model` group mirrors the `locker-room` pattern
+
+- **Decision**: `model = sub.add_parser("model", ...)`; `model_sub = model.add_subparsers(dest="model_cmd", required=True)`; register `execute` under it.
+- **Rationale**: `build_parser()` already uses this nested pattern for `locker-room`; stay consistent and extensible.
+
+## Decision 3 — Full nomenclature purge (breaking, no migration)
+
+- **Decision**: Rename everything that names this command:
+  - env var `BLITZ_IMPLEMENT_MODEL` → `BLITZ_EXECUTE_MODEL`
+  - run-snapshot path `.blitz/implement/runs/` → `.blitz/execute/runs/`
+  - module `blitz_cli/_implement.py` → `blitz_cli/_execute.py`
+  - handler `_cmd_implement` → `_cmd_execute`
+  - test file `tests/test_implement.py` → `tests/test_execute.py`
+  - all imports/usages in `cli.py`, `_ontology.py`, tests
+- **Rationale**: User wants the "implement" nomenclature gone. These are internal but user-facing (env var, on-disk path).
+- **Consequence**: Existing `.blitz/implement/runs/` snapshots and `BLITZ_IMPLEMENT_MODEL` settings stop working; no migration is provided (accepted by user).
+
+## Decision 4 — What is explicitly NOT renamed
+
+- The `/implement` playbook SDD slash-command and its `__SPECKIT_COMMAND_IMPLEMENT__` token — a separate lifecycle verb shared across the playbook ecosystem.
+- The `"implemented"` feature lifecycle stage in `_ontology.py` (`_infer_stage`) and its test.
+- Generic English "implementation"/"implementer" prose (docstrings, plan-template title, SYSTEM_PROMPT).
+
+## Decision 5 — Rendered playbook CLI references
+
+- **Decision**: Update `blitz implement … --local-only` invocations inside `playbooks/commands/implement.md`, `playbooks/commands/tasks.md`, and `templates/workspace_playbook.md.tmpl` to `blitz model execute …`. Do not rename the `/implement` slash-command itself.

blitz_cli-0.11.0/specs/001-cli-model-namespace/spec.md

@@ -0,0 +1,69 @@
+# Feature Specification: CLI model namespace (retire "implement")
+
+**Feature Branch**: `001-cli-model-namespace`
+
+**Created**: 2026-07-14
+
+**Status**: Draft
+
+**Input**: User description: "Update blitz-cli to put the implement command under a 'model' namespace and rename implement to execute (`blitz model execute`). Hard rename with no error stub, and remove the 'implement' nomenclature everywhere it names this command — including the env var, the run-snapshot path, and internal module/handler names."
+
+## User Scenarios & Testing *(mandatory)*
+
+### User Story 1 - Run the execution flow via the new namespaced command (Priority: P1)
+
+A developer who previously ran `blitz implement` now runs `blitz model execute` and gets the identical behavior, flags, and output. The command lives under a new `model` command group so related model-lifecycle commands can be added there later.
+
+**Why this priority**: This is the core of the feature.
+
+**Independent Test**: Run `blitz model execute` with the arguments previously passed to `blitz implement` and confirm identical behavior. `blitz model --help` lists `execute`; `blitz --help` lists `model` and not `implement`.
+
+**Acceptance Scenarios**:
+
+1. **Given** a repo where `blitz implement <args>` previously worked, **When** the user runs `blitz model execute <args>`, **Then** the command performs the same work and produces equivalent output/exit code.
+2. **Given** the CLI is installed, **When** the user runs `blitz model --help`, **Then** `execute` appears with the help text formerly shown for `implement`.
+3. **Given** the CLI is installed, **When** the user runs `blitz --help`, **Then** `model` appears and `implement` does not.
+4. **Given** the CLI is installed, **When** the user runs `blitz implement`, **Then** the standard argparse "invalid choice" error is shown and exit is non-zero (no special stub, no forwarding).
+
+### Edge Cases
+
+- `blitz model` with no subcommand: prints the `model` group help and exits non-zero (subparser required).
+- All flags/positional arguments previously accepted by `implement` are accepted unchanged by `execute`.
+- The model-selection env var is now `BLITZ_EXECUTE_MODEL`; the old `BLITZ_IMPLEMENT_MODEL` is no longer read (breaking change, accepted).
+- Run snapshots are now written under `.blitz/execute/runs/`; the old `.blitz/implement/runs/` path is no longer read or written (breaking change, accepted — no migration).
+
+## Requirements *(mandatory)*
+
+### Functional Requirements
+
+- **FR-001**: The CLI MUST expose a `model` command group at the top level.
+- **FR-002**: The CLI MUST provide `model execute` performing exactly the behavior of the former top-level `implement` command, with identical flags, positional arguments, defaults, and exit codes.
+- **FR-003**: The CLI MUST NOT expose a top-level `implement` command in any form (no working command and no special error stub); invoking `blitz implement` yields the default argparse invalid-choice failure.
+- **FR-004**: Help output MUST reflect the new structure: `model` at top level, `execute` under `model`, no `implement` anywhere.
+- **FR-005**: README and any in-repo documentation or rendered playbook command text referencing the `blitz implement` CLI invocation MUST be updated to `blitz model execute`.
+- **FR-006**: The "implement" nomenclature naming THIS command MUST be removed from the code: the env var `BLITZ_IMPLEMENT_MODEL` becomes `BLITZ_EXECUTE_MODEL`; the run-snapshot path `.blitz/implement/runs/` becomes `.blitz/execute/runs/`; the module `_implement.py` becomes `_execute.py`; the handler `_cmd_implement` becomes `_cmd_execute`; all imports/references update accordingly.
+- **FR-007**: The existing test suite MUST be updated to the new command, env var, path, and module names (including renaming `tests/test_implement.py` to `tests/test_execute.py`), and a test MUST assert `blitz model execute` is wired and no top-level `implement` command exists.
+
+**Out of scope (NOT renamed)**: the separate `/implement` playbook SDD lifecycle slash-command and its `__SPECKIT_COMMAND_IMPLEMENT__` token; the "implemented" feature lifecycle stage in `_ontology.py`; generic English "implementation" prose. These are distinct from the `blitz implement` CLI command.
+
+### Key Entities
+
+- **`model` command group**: A namespace for model-lifecycle commands; currently holds `execute`.
+- **`execute` subcommand**: The relocated, renamed former `implement` command; unchanged behavior.
+
+## Success Criteria *(mandatory)*
+
+### Measurable Outcomes
+
+- **SC-001**: 100% of the behavior/flags previously under `blitz implement` are available under `blitz model execute`.
+- **SC-002**: `blitz implement` no longer runs anything; it exits non-zero with the standard invalid-choice error.
+- **SC-003**: No occurrence of the strings `blitz implement`, `BLITZ_IMPLEMENT_MODEL`, `.blitz/implement/runs`, `_implement`, or `_cmd_implement` remains in `blitz_cli/`, `README.md`, `tests/`, or rendered playbook CLI references (verifiable by search). Matches limited to the out-of-scope items above are acceptable.
+- **SC-004**: The full test suite passes after the rename.
+
+## Assumptions
+
+- Hard rename confirmed: no alias, no error stub. `blitz implement` simply ceases to exist as a choice.
+- Full nomenclature purge confirmed for env var, run-snapshot path, and internal module/handler names — breaking, with no migration of existing `.blitz/implement/runs/` snapshots or `BLITZ_IMPLEMENT_MODEL` settings.
+- The `_execute` engine behavior (task driving, retries, snapshots) is otherwise reused unchanged; only names and the snapshot directory change.
+- `homebrew-tap` and other repos are unaffected (they package the binary, not subcommands).
+- The `/implement` playbook SDD command and the `"implemented"` lifecycle stage are explicitly out of scope.

blitz_cli-0.11.0/specs/001-cli-model-namespace/tasks.md

@@ -0,0 +1,83 @@
+---
+description: "Task list for CLI model namespace (retire 'implement')"
+---
+
+# Tasks: CLI model namespace (retire "implement")
+
+**Input**: Design documents from `specs/001-cli-model-namespace/`
+
+**Prerequisites**: plan.md, spec.md, research.md, contracts/cli-commands.md, quickstart.md
+
+**Tests**: Included — FR-007 requires migrating/renaming the suite.
+
+**Organization**: Single user story (US1) — the new `model execute` surface plus the full nomenclature purge. No error-stub story.
+
+## Format: `[ID] [P?] [L?] [US1] Description`
+
+- **[P]**: parallelizable (different file)
+- **[L]**: local-model eligible (shell command verified by exit code)
+
+---
+
+## Phase 1: Setup
+
+- [X] T001 [L] Baseline green: `cd /home/ike/companies/sparepartslabs/blitz-dev-tools/blitz-cli && pip install -e . >/dev/null 2>&1 && pytest -q`. Expected: passes before changes.
+
+---
+
+## Phase 2: User Story 1 — `blitz model execute` + retire "implement" (P1) 🎯 MVP
+
+**Goal**: `blitz model execute` replaces `blitz implement` with identical behavior; the "implement" nomenclature naming this command is gone from code, env var, run path, and tests. `blitz implement` is an invalid choice.
+
+**Independent Test**: quickstart.md — help output correct, `blitz implement` errors, snapshots land under `.blitz/execute/runs/`, grep finds no stray nomenclature, `pytest` passes.
+
+### Engine module rename
+
+- [X] T002 [L] [US1] Rename the engine module: `cd /home/ike/companies/sparepartslabs/blitz-dev-tools/blitz-cli && git mv blitz_cli/_implement.py blitz_cli/_execute.py` (use `mv` if not tracked). Expected: exit 0.
+- [X] T003 [US1] In `blitz_cli/_execute.py`, update the run-snapshot path from `.blitz/implement/runs` to `.blitz/execute/runs` at every occurrence (currently the docstring ~L240-241, the glob `.blitz/implement/runs/*/usage.json` ~L245, and `repo / ".blitz" / "implement" / "runs"` ~L292), and update the module docstring's `implement` playbook reference to `execute`. Do NOT change the `SYSTEM_PROMPT` "code implementer" prose.
+
+### CLI wiring
+
+- [X] T004 [US1] In `blitz_cli/cli.py`, rename handler `def _cmd_implement(args)` → `def _cmd_execute(args)`; change its `from blitz_cli import _implement` to `from blitz_cli import _execute` and update all `_implement.` references in the function body to `_execute.` (find_tasks_file, local_model_config, DEFAULT_MODEL, run); change the env read `os.environ.get("BLITZ_IMPLEMENT_MODEL")` → `os.environ.get("BLITZ_EXECUTE_MODEL")` and the adjacent comment.
+- [X] T005 [US1] In `blitz_cli/cli.py` `build_parser()`, replace the whole top-level `impl = sub.add_parser("implement", ...)` block (through `impl.set_defaults(func=_cmd_implement)`, ~L293-334) with: `model = sub.add_parser("model", help="Model lifecycle commands.")`; `model_sub = model.add_subparsers(dest="model_cmd", required=True)`; `execute = model_sub.add_parser("execute", help=...)` re-attaching the identical arguments (`tasks`, `--repo`, `--model`, `--local-only`, `--ollama-url`, `--max-retries`, `--start-at`) verbatim; update the `--model` help text `BLITZ_IMPLEMENT_MODEL` → `BLITZ_EXECUTE_MODEL` and `snapshots under .blitz/implement/runs/` → `.blitz/execute/runs/`; end with `execute.set_defaults(func=_cmd_execute)`. Follow the `locker-room` nested pattern. No `implement` parser remains.
+
+### Ontology reference
+
+- [X] T006 [US1] In `blitz_cli/_ontology.py`, change `from blitz_cli import _activity, _implement, _playbooks` → `... _execute ...` and update every `_implement.` usage (~L355 parse_tasks, ~L530 usage_by_spec) to `_execute.`. KEEP the `"implemented"` return in `_infer_stage` (~L366) and the "the implement" comment's meaning — those are the lifecycle stage, not the CLI command. If `_ontology.py` builds any `.blitz/implement/runs` path, change it to `.blitz/execute/runs`.
+
+### Docs & rendered playbook refs
+
+- [X] T007 [P] [US1] Update `README.md`: "Top-level commands" line (~L15) list `model` not `implement`; the `## Implement:` section heading and body (~L35-50) → `blitz model execute` usage; `BLITZ_IMPLEMENT_MODEL` (~L55) → `BLITZ_EXECUTE_MODEL`; `.blitz/implement/runs/` (~L45) → `.blitz/execute/runs/`.
+- [X] T008 [P] [US1] Update rendered playbook CLI refs to `blitz model execute … --local-only`: `blitz_cli/playbooks/commands/implement.md` (~L154, L158, L162), `blitz_cli/playbooks/commands/tasks.md` (~L209, L243), `blitz_cli/templates/workspace_playbook.md.tmpl` (~L24-25). Do NOT rename the `/implement` slash-command, its filename, or `agent: implement` frontmatter.
+
+### Tests
+
+- [X] T009 [US1] Rename `tests/test_implement.py` → `tests/test_execute.py` (`git mv`), change `from blitz_cli import _implement` → `_execute` and every `_implement.` → `_execute.`, and update the `.blitz/implement/runs` path (~L233) → `.blitz/execute/runs`.
+- [X] T010 [US1] In `tests/test_ontology.py`, update the run dir `.blitz/implement/runs` (~L68) → `.blitz/execute/runs`. Keep the `"implemented"` stage assertions (~L49) unchanged; the test name `test_feature_node_carries_implement_usage` may be left or renamed to `..._execute_usage` (cosmetic).
+- [X] T011 [P] [US1] In `tests/test_cli.py`, add tests: (a) `build_parser().parse_args(["model","execute"])` resolves `func == _cmd_execute`; (b) parsing `["implement"]` raises `SystemExit` (invalid choice); (c) `model` is present and `implement` absent in the top-level choices.
+
+---
+
+## Phase 3: Verification
+
+- [X] T012 [L] Run the suite: `cd /home/ike/companies/sparepartslabs/blitz-dev-tools/blitz-cli && pytest -q`. Expected: all pass.
+- [X] T013 [L] No stray nomenclature: `cd /home/ike/companies/sparepartslabs/blitz-dev-tools/blitz-cli && ! grep -rnE "blitz implement|BLITZ_IMPLEMENT_MODEL|\.blitz/implement/runs|_cmd_implement|_implement" blitz_cli README.md tests`. Expected: exit 0 (no matches).
+- [X] T014 [L] Surface check per quickstart.md: `blitz --help`, `blitz model --help`, `blitz model execute --help`, `blitz implement; echo exit=$?`. Confirm `model`/`execute` present, `implement` invalid.
+
+---
+
+## Dependencies
+
+- T001 → all.
+- T002 (module move) → T003, T004, T006, T009 (they reference `_execute`).
+- T004 → T005 (handler must exist before `set_defaults(func=_cmd_execute)`), same file `cli.py`, sequential.
+- T007, T008, T011 [P] — independent files.
+- T012-T014 last (after all edits).
+
+## Parallel opportunities
+
+- T007, T008 (docs/templates) and T011 (test_cli.py) run in parallel once code edits land.
+
+## MVP scope
+
+All of US1 is the deliverable; there is no separate secondary story.

{blitz_cli-0.10.0 → blitz_cli-0.11.0}/tests/test_cli.py

@@ -43,6 +43,25 @@ def test_locker_room_make_verbs_resolve_to_the_make_passthrough():
     assert logs.run_dir == "./x"
 
 
+def test_model_execute_resolves():
+    args = cli.build_parser().parse_args(["model", "execute", "specs/001/tasks.md"])
+    assert args.func is cli._cmd_execute
+    assert args.tasks == "specs/001/tasks.md"
+    assert args.max_retries == 2
+
+
+def test_old_implement_command_is_gone():
+    import pytest
+    with pytest.raises(SystemExit):
+        cli.build_parser().parse_args(["implement"])
+
+
+def test_model_group_requires_subcommand():
+    import pytest
+    with pytest.raises(SystemExit):
+        cli.build_parser().parse_args(["model"])
+
+
 def test_runtime_commands_are_not_in_the_cli():
     # The node runs watch/ontologize/mcp; the CLI must not expose them.
     parser = cli.build_parser()

blitz_cli-0.10.0/tests/test_implement.py → blitz_cli-0.11.0/tests/test_execute.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from blitz_cli import _implement
+from blitz_cli import _execute
 
 TASKS_MD = """\
 # Tasks: Example
@@ -33,7 +33,7 @@ def _write_tasks(tmp_path):
 
 
 def test_parse_tasks_ids_done_phases_and_verify():
-    tasks, verify = _implement.parse_tasks(TASKS_MD)
+    tasks, verify = _execute.parse_tasks(TASKS_MD)
     assert [t["id"] for t in tasks] == ["T001", "T002", "T003", "T004"]
     assert [t["done"] for t in tasks] == [False, True, False, False]
     assert [t["phase"] for t in tasks] == [1, 1, 2, 2]
@@ -48,7 +48,7 @@ def test_parse_actions_orders_writes_and_runs():
         "===RUN===\n```\nmkdir -p tests\n```\n"
         "===WRITE src/mod.py===\n```python\nX = 1\n```\n"
     )
-    actions = _implement.parse_actions(reply)
+    actions = _execute.parse_actions(reply)
     assert actions == [("run", "mkdir -p tests", None), ("write", "src/mod.py", "X = 1")]
 
 
@@ -59,14 +59,14 @@ def test_apply_actions_writes_snapshots_and_rejects_escape(tmp_path):
     snap.mkdir()
     (repo / "a.txt").write_text("old\n")
 
-    ok, err = _implement.apply_actions(
+    ok, err = _execute.apply_actions(
         repo, [("write", "a.txt", "new")], snap, "T001", 0, print_fn=lambda *_: None
     )
     assert ok, err
     assert (repo / "a.txt").read_text() == "new\n"
     assert (snap / "T001.a0.a.txt").read_text() == "old\n"
 
-    ok, err = _implement.apply_actions(
+    ok, err = _execute.apply_actions(
         repo, [("write", "../evil.txt", "x")], snap, "T001", 0, print_fn=lambda *_: None
     )
     assert not ok and "escapes the repo" in err
@@ -74,14 +74,14 @@ def test_apply_actions_writes_snapshots_and_rejects_escape(tmp_path):
 
 
 def test_apply_actions_reports_failed_command(tmp_path):
-    ok, err = _implement.apply_actions(
+    ok, err = _execute.apply_actions(
         tmp_path, [("run", "exit 3", None)], tmp_path, "T001", 0, print_fn=lambda *_: None
     )
     assert not ok and "exit 3" in err
 
 
 def test_apply_actions_empty_reply_is_an_error(tmp_path):
-    ok, err = _implement.apply_actions(
+    ok, err = _execute.apply_actions(
         tmp_path, [], tmp_path, "T001", 0, print_fn=lambda *_: None
     )
     assert not ok and "No action blocks" in err
@@ -89,7 +89,7 @@ def test_apply_actions_empty_reply_is_an_error(tmp_path):
 
 def test_mark_done_checks_exactly_one_box(tmp_path):
     f = _write_tasks(tmp_path)
-    _implement.mark_done(f, "T001")
+    _execute.mark_done(f, "T001")
     text = f.read_text()
     assert "- [x] T001 " in text
     assert "- [ ] T003 " in text
@@ -98,7 +98,7 @@ def test_mark_done_checks_exactly_one_box(tmp_path):
 def test_gather_context_inlines_referenced_files(tmp_path):
     (tmp_path / "src").mkdir()
     (tmp_path / "src" / "mod.py").write_text("X = 1\n")
-    ctx = _implement.gather_context(tmp_path, "EDIT `src/mod.py` and `src/missing.py`.")
+    ctx = _execute.gather_context(tmp_path, "EDIT `src/mod.py` and `src/missing.py`.")
     assert "current contents of src/mod.py" in ctx
     assert "1\tX = 1" in ctx
     assert "missing.py" not in ctx
@@ -111,10 +111,10 @@ def test_find_tasks_file_unique_incomplete(tmp_path):
     open_.mkdir(parents=True)
     done.joinpath("tasks.md").write_text("- [x] T001 done\n")
     open_.joinpath("tasks.md").write_text("- [ ] T001 todo\n")
-    assert _implement.find_tasks_file(tmp_path) == open_ / "tasks.md"
+    assert _execute.find_tasks_file(tmp_path) == open_ / "tasks.md"
     # Two incomplete lists -> ambiguous -> None.
     done.joinpath("tasks.md").write_text("- [ ] T001 todo\n")
-    assert _implement.find_tasks_file(tmp_path) is None
+    assert _execute.find_tasks_file(tmp_path) is None
 
 
 def test_run_end_to_end_with_fake_model(tmp_path):
@@ -131,7 +131,7 @@ def test_run_end_to_end_with_fake_model(tmp_path):
         return replies[tid]
 
     logs = []
-    rc = _implement.run(
+    rc = _execute.run(
         repo=repo, tasks_file=tasks_file, call_model=fake_model,
         run_root=tmp_path / "runs", print_fn=logs.append,
     )
@@ -148,7 +148,7 @@ def test_run_end_to_end_with_fake_model(tmp_path):
 
 
 def test_parse_tasks_local_marker():
-    tasks, _ = _implement.parse_tasks(
+    tasks, _ = _execute.parse_tasks(
         "## Phase 1: x\n\n"
         "- [ ] T001 [P] [L] CREATE a file.\n"
         "- [ ] T002 [L] [US1] Run `true`.\n"
@@ -169,14 +169,14 @@ def test_local_model_config_walks_up_to_workspace(tmp_path):
         json.dumps({"local_model": {"model": "ws-model"}})
     )
     # No repo-level config -> workspace config wins.
-    assert _implement.local_model_config(repo) == {"model": "ws-model"}
+    assert _execute.local_model_config(repo) == {"model": "ws-model"}
     # Repo-level config takes precedence.
     (repo / ".blitz" / "config.json").write_text(
         json.dumps({"local_model": {"model": "repo-model"}})
     )
-    assert _implement.local_model_config(repo) == {"model": "repo-model"}
+    assert _execute.local_model_config(repo) == {"model": "repo-model"}
     # Nothing configured anywhere -> {}.
-    assert _implement.local_model_config(tmp_path) == {}
+    assert _execute.local_model_config(tmp_path) == {}
 
 
 def test_run_local_only_stops_at_first_frontier_task(tmp_path):
@@ -196,7 +196,7 @@ def test_run_local_only_stops_at_first_frontier_task(tmp_path):
         return "===RUN===\n```\ntrue\n```"
 
     logs = []
-    rc = _implement.run(
+    rc = _execute.run(
         repo=repo, tasks_file=tasks_file, call_model=fake_model,
         local_only=True, run_root=tmp_path / "runs", print_fn=logs.append,
     )
@@ -212,7 +212,7 @@ def test_run_local_only_warns_when_no_markers(tmp_path):
     tasks_file = tmp_path / "tasks.md"
     tasks_file.write_text("- [ ] T001 Do a thing.\n")
     logs = []
-    rc = _implement.run(
+    rc = _execute.run(
         repo=tmp_path, tasks_file=tasks_file, call_model=lambda m: "",
         local_only=True, run_root=tmp_path / "runs", print_fn=logs.append,
     )
@@ -222,15 +222,15 @@ def test_run_local_only_warns_when_no_markers(tmp_path):
 
 def test_spec_name_from_specs_layout(tmp_path):
     tasks = tmp_path / "specs" / "001-my-feature" / "tasks.md"
-    assert _implement.spec_name(tmp_path, tasks) == "001-my-feature"
+    assert _execute.spec_name(tmp_path, tasks) == "001-my-feature"
     other = tmp_path / "docs" / "tasks.md"
-    assert _implement.spec_name(tmp_path, other) == "docs/tasks.md"
+    assert _execute.spec_name(tmp_path, other) == "docs/tasks.md"
 
 
 def test_usage_by_spec_aggregates_runs(tmp_path):
     import json
 
-    runs = tmp_path / ".blitz" / "implement" / "runs"
+    runs = tmp_path / ".blitz" / "execute" / "runs"
     for stamp, out in (("20260714-1", 100), ("20260714-2", 50)):
         d = runs / stamp
         d.mkdir(parents=True)
@@ -241,7 +241,7 @@ def test_usage_by_spec_aggregates_runs(tmp_path):
     (runs / "broken").mkdir()
     (runs / "broken" / "usage.json").write_text("not json")
 
-    agg = _implement.usage_by_spec(tmp_path)
+    agg = _execute.usage_by_spec(tmp_path)
     assert agg == {"001-a": {
         "input": 2000, "output": 150, "calls": 6, "runs": 2,
         "models": ["qwen2.5-14b-28k"],
@@ -264,7 +264,7 @@ def test_run_records_token_usage(tmp_path):
         return replies[tid], {"input": 100, "output": 10}
 
     logs = []
-    rc = _implement.run(
+    rc = _execute.run(
         repo=repo, tasks_file=tasks_file, call_model=fake_model,
         run_root=tmp_path / "runs", print_fn=logs.append,
     )
@@ -272,7 +272,7 @@ def test_run_records_token_usage(tmp_path):
     rundir = next((tmp_path / "runs").iterdir())
     usage = json.loads((rundir / "usage.json").read_text())
     assert usage["spec"] == str(tasks_file.relative_to(repo))  # not under specs/
-    assert usage["model"] == _implement.DEFAULT_MODEL
+    assert usage["model"] == _execute.DEFAULT_MODEL
     assert usage["tasks"]["T001"] == {"input": 100, "output": 10, "calls": 1}
     assert usage["total"] == {"input": 200, "output": 20, "calls": 2}
     assert any("T001: DONE (100 in / 10 out tokens)" in ln for ln in logs)
@@ -286,7 +286,7 @@ def test_run_flushes_usage_on_failure(tmp_path):
     tasks_file = repo / "tasks.md"
     tasks_file.write_text("## Phase 1: x\n\n- [ ] T001 Run `false`.\n")
 
-    rc = _implement.run(
+    rc = _execute.run(
         repo=repo, tasks_file=tasks_file,
         call_model=lambda m: ("===RUN===\n```\nexit 7\n```", {"input": 50, "output": 5}),
         max_retries=1, run_root=tmp_path / "runs", print_fn=lambda *_: None,
@@ -308,7 +308,7 @@ def test_run_retries_with_error_feedback_then_stops(tmp_path):
         calls.append(messages)
         return "===RUN===\n```\nexit 7\n```"
 
-    rc = _implement.run(
+    rc = _execute.run(
         repo=repo, tasks_file=tasks_file, call_model=failing_model,
         max_retries=1, run_root=tmp_path / "runs", print_fn=lambda *_: None,
     )
@@ -327,7 +327,7 @@ def test_run_phase_verify_failure_fails_last_task(tmp_path):
         "**Phase 1 verification**: `test -f produced.txt` succeeds.\n"
     )
 
-    rc = _implement.run(
+    rc = _execute.run(
         repo=repo, tasks_file=tasks_file,
         call_model=lambda m: "===RUN===\n```\ntrue\n```",
         max_retries=0, run_root=tmp_path / "runs", print_fn=lambda *_: None,

{blitz_cli-0.10.0 → blitz_cli-0.11.0}/tests/test_ontology.py

@@ -62,10 +62,10 @@ def test_playbook_nodes_carry_command_docs(workspace):
     assert docs["playbook"].strip()
 
 
-def test_feature_node_carries_implement_usage(tmp_path):
+def test_feature_node_carries_execute_usage(tmp_path):
     ws = tmp_path / "ws"
     repo = _make_repo(ws, "api", specs={"001-endpoint": {"spec.md": "# s", "tasks.md": "# t"}})
-    rundir = repo / ".blitz" / "implement" / "runs" / "20260714-120000"
+    rundir = repo / ".blitz" / "execute" / "runs" / "20260714-120000"
     rundir.mkdir(parents=True)
     (rundir / "usage.json").write_text(json.dumps({
         "spec": "001-endpoint", "model": "qwen2.5-14b-28k",