blitz-cli 0.14.0__tar.gz → 0.15.0__tar.gz

{blitz_cli-0.14.0 → blitz_cli-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blitz-cli
-Version: 0.14.0
+Version: 0.15.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
@@ -79,16 +79,16 @@ Ollama endpoint comes from `--ollama-url` or `OLLAMA_HOST`; the model from
 
 `blitz model execute --collect` records every generation attempt as DPO
 training data. By default it writes straight to the activity SQLite database
-(`ACTIVITY_DB_PATH`, else `data/activity.db`). With `COLLECT_ENDPOINT` set,
+(`BLITZ_ACTIVITY_DB_PATH`, else `data/activity.db`). With `BLITZ_COLLECT_ENDPOINT` set,
 the same writes go over HTTP JSON to a collect ingest server instead, so the
 collector needs no filesystem access to the database:
 
 ```bash
 # on the locker-room node (default port 1739, binds all interfaces, no auth):
-ACTIVITY_DB_PATH=data/activity.db blitz locker-room collect-serve
+BLITZ_ACTIVITY_DB_PATH=data/activity.db blitz locker-room collect-serve
 
 # on the collecting machine:
-COLLECT_ENDPOINT=http://locker-room-host:1739 blitz model execute --collect
+BLITZ_COLLECT_ENDPOINT=http://locker-room-host:1739 blitz model execute --collect
 ```
 
 Each attempt is acknowledged by the endpoint before the next model call
@@ -151,7 +151,7 @@ The `mcp` role serves this: point an agent's MCP config at
 
 `blitz locker-room train` runs an on-demand QLoRA fine-tune of the watcher corpus
 in the trainer container (needs a GPU); adapters land in `./train-out`. Override
-the base model with `BASE_MODEL_HF` or `blitz locker-room init --base-model`.
+the base model with `BLITZ_BASE_MODEL_HF` or `blitz locker-room init --base-model`.
 
 ## Activity: replay a coding-agent session
 

{blitz_cli-0.14.0 → blitz_cli-0.15.0}/README.md

@@ -60,16 +60,16 @@ Ollama endpoint comes from `--ollama-url` or `OLLAMA_HOST`; the model from
 
 `blitz model execute --collect` records every generation attempt as DPO
 training data. By default it writes straight to the activity SQLite database
-(`ACTIVITY_DB_PATH`, else `data/activity.db`). With `COLLECT_ENDPOINT` set,
+(`BLITZ_ACTIVITY_DB_PATH`, else `data/activity.db`). With `BLITZ_COLLECT_ENDPOINT` set,
 the same writes go over HTTP JSON to a collect ingest server instead, so the
 collector needs no filesystem access to the database:
 
 ```bash
 # on the locker-room node (default port 1739, binds all interfaces, no auth):
-ACTIVITY_DB_PATH=data/activity.db blitz locker-room collect-serve
+BLITZ_ACTIVITY_DB_PATH=data/activity.db blitz locker-room collect-serve
 
 # on the collecting machine:
-COLLECT_ENDPOINT=http://locker-room-host:1739 blitz model execute --collect
+BLITZ_COLLECT_ENDPOINT=http://locker-room-host:1739 blitz model execute --collect
 ```
 
 Each attempt is acknowledged by the endpoint before the next model call
@@ -132,7 +132,7 @@ The `mcp` role serves this: point an agent's MCP config at
 
 `blitz locker-room train` runs an on-demand QLoRA fine-tune of the watcher corpus
 in the trainer container (needs a GPU); adapters land in `./train-out`. Override
-the base model with `BASE_MODEL_HF` or `blitz locker-room init --base-model`.
+the base model with `BLITZ_BASE_MODEL_HF` or `blitz locker-room init --base-model`.
 
 ## Activity: replay a coding-agent session
 

{blitz_cli-0.14.0 → blitz_cli-0.15.0}/blitz_cli/__init__.py

@@ -30,4 +30,4 @@ Commands:
 
 __all__ = ["__version__"]
 
-__version__ = "0.12.0"
+__version__ = "0.15.0"

{blitz_cli-0.14.0 → blitz_cli-0.15.0}/blitz_cli/_collect.py

@@ -4,7 +4,7 @@
 `CollectStore` owns four tables (`collect_runs`, `collect_attempts`,
 `dpo_pairs`, `sft_queue`) in the same locker-room activity database that
 `_corpus.py`'s `TurnStore` writes its transcript corpus to (default
-`data/activity.db`, env override `ACTIVITY_DB_PATH`, WAL journal). Like
+`data/activity.db`, env override `BLITZ_ACTIVITY_DB_PATH`, WAL journal). Like
 `TurnStore`, it is the one writer of its tables and creates its schema on
 first connect.
 
@@ -124,9 +124,9 @@ SFT_FIELDS = ("run_id", "task_id", "prompt_messages_json")
 
 
 def default_db_path() -> Path:
-    """The activity database path: ACTIVITY_DB_PATH env override, else the
+    """The activity database path: BLITZ_ACTIVITY_DB_PATH env override, else the
     conventional data/activity.db relative to the CWD (same idiom as _train.py)."""
-    return Path(os.environ.get("ACTIVITY_DB_PATH", "data/activity.db"))
+    return Path(os.environ.get("BLITZ_ACTIVITY_DB_PATH", "data/activity.db"))
 
 
 def _now_iso() -> str:

{blitz_cli-0.14.0 → blitz_cli-0.15.0}/blitz_cli/_collect_http.py

@@ -1,7 +1,7 @@
 """HTTP collection sink and buffer/flush tooling for the collect ingest
 endpoint (see _collect_server.py for the server side).
 
-`HttpCollectSink` is the COLLECT_ENDPOINT-selected counterpart of
+`HttpCollectSink` is the BLITZ_COLLECT_ENDPOINT-selected counterpart of
 `_collect.CollectStore`: it exposes the same methods the execute loop calls
 (check_writable, insert_run, insert_attempt, finish_run,
 insert_sft_placeholder) but delivers each payload synchronously over HTTP, so
@@ -60,7 +60,7 @@ def _path_for(kind: str, payload: dict) -> str:
 class HttpCollectSink:
     """Collection sink that writes through the ingest endpoint instead of
     opening the activity database. Duck-types CollectStore's writer surface;
-    selected by cli._cmd_execute when COLLECT_ENDPOINT is set."""
+    selected by cli._cmd_execute when BLITZ_COLLECT_ENDPOINT is set."""
 
     def __init__(self, endpoint: str, timeout: int = _TIMEOUT):
         self.endpoint = endpoint.rstrip("/")

{blitz_cli-0.14.0 → blitz_cli-0.15.0}/blitz_cli/_collect_server.py

@@ -6,7 +6,7 @@ storage behind the endpoint can change without touching any collector. Shipped
 here as an importable module so the locker-room node image can run it with a
 thin entrypoint; `blitz locker-room collect-serve` starts it host-side.
 
-API (contracts/ingest-api.md): default port 1739 (COLLECT_PORT), bind 0.0.0.0,
+API (contracts/ingest-api.md): default port 1739 (BLITZ_COLLECT_PORT), bind 0.0.0.0,
 no auth, same localhost/LAN trust posture as the mcp role on 1738.
 
   GET  /v1/health                        -> {"status": "ok"}
@@ -203,10 +203,10 @@ def serve(
     print_fn=print,
 ) -> None:
     """Blocking entrypoint: resolve defaults from the environment
-    (ACTIVITY_DB_PATH, COLLECT_PORT) and serve until interrupted."""
+    (BLITZ_ACTIVITY_DB_PATH, BLITZ_COLLECT_PORT) and serve until interrupted."""
     db = Path(db_path) if db_path is not None else _collect.default_db_path()
     if port is None:
-        port = int(os.environ.get("COLLECT_PORT", DEFAULT_PORT))
+        port = int(os.environ.get("BLITZ_COLLECT_PORT", DEFAULT_PORT))
     server = make_server(db, host=host, port=port, verbose=True)
     print_fn(f"collect ingest endpoint listening on {host}:{port}, database {db}")
     try:

{blitz_cli-0.14.0 → blitz_cli-0.15.0}/blitz_cli/_train.py

@@ -17,17 +17,17 @@ chat-formatted, tool-calling trajectories (native Claude Code tool names --
 Read/Edit/Write/Bash/...), and an instruction-tuned checkpoint already
 understands a chat template and basic tool-calling, the right starting point for
 further SFT rather than a raw base model. 14B needs real headroom (an 80GB-class
-GPU); on a 16GB-class card use 7B. Override the base model via BASE_MODEL_HF (its
-scaffold-time default lives in docker-compose.yml) -- and PARAMS_B to match,
+GPU); on a 16GB-class card use 7B. Override the base model via BLITZ_BASE_MODEL_HF (its
+scaffold-time default lives in docker-compose.yml) -- and BLITZ_PARAMS_B to match,
 since it drives the LoRA rank/batch-size defaults in _scaffold.build_config.
 
-SEQ_LEN defaults to 16384. Measured against the real corpus + Qwen tokenizer with
+BLITZ_SEQ_LEN defaults to 16384. Measured against the real corpus + Qwen tokenizer with
 the full tool-schema block on every example: at 2048 the schema tax pushes 77.6%
 of turns over budget (vs. 42.5% with no schema); at 16384 that gap is +0.8pp
-(7.3% vs. 6.5%). Packing splits a turn longer than SEQ_LEN across separate steps
+(7.3% vs. 6.5%). Packing splits a turn longer than BLITZ_SEQ_LEN across separate steps
 with no attention between the pieces -- set it from actual VRAM.
 
-PER_DEVICE_BATCH_SIZE overrides build_config's params_b-driven batch size
+BLITZ_PER_DEVICE_BATCH_SIZE overrides build_config's params_b-driven batch size
 directly, independent of LoRA rank; grad_accum rescales to hold the effective
 batch size steady, so it has no training-dynamics tradeoff, just more (smaller)
 steps for the same per-step memory.
@@ -70,12 +70,12 @@ def run() -> int:
 
     mlflow.set_tracking_uri("sqlite:///training.db")
 
-    base_model_hf = os.environ.get("BASE_MODEL_HF", "Qwen/Qwen2.5-Coder-14B-Instruct")
-    params_b = float(os.environ.get("PARAMS_B", "14"))
-    seq_len = _scaffold.clamp_seq_len(int(os.environ.get("SEQ_LEN", "16384")))
-    eval_fraction = float(os.environ.get("EVAL_FRACTION", "0.1"))
-    db_path = os.environ.get("ACTIVITY_DB_PATH", "data/activity.db")
-    save_steps = int(os.environ.get("SAVE_STEPS", "50"))
+    base_model_hf = os.environ.get("BLITZ_BASE_MODEL_HF", "Qwen/Qwen2.5-Coder-14B-Instruct")
+    params_b = float(os.environ.get("BLITZ_PARAMS_B", "14"))
+    seq_len = _scaffold.clamp_seq_len(int(os.environ.get("BLITZ_SEQ_LEN", "16384")))
+    eval_fraction = float(os.environ.get("BLITZ_EVAL_FRACTION", "0.1"))
+    db_path = os.environ.get("BLITZ_ACTIVITY_DB_PATH", "data/activity.db")
+    save_steps = int(os.environ.get("BLITZ_SAVE_STEPS", "50"))
     all_tool_names = frozenset(_tool_schemas.TOOL_SCHEMAS)
 
     cfg = _scaffold.build_config(
@@ -85,7 +85,7 @@ def run() -> int:
         seq_len=seq_len,
         eval_fraction=eval_fraction,
     )
-    batch_override = os.environ.get("PER_DEVICE_BATCH_SIZE")
+    batch_override = os.environ.get("BLITZ_PER_DEVICE_BATCH_SIZE")
     if batch_override:
         cfg = _scaffold.apply_batch_override(cfg, int(batch_override))
 
@@ -118,7 +118,7 @@ def run() -> int:
     if not examples:
         print(
             f"No training-bucket turns in {db_path} -- let the watcher run longer, "
-            "or lower EVAL_FRACTION.",
+            "or lower BLITZ_EVAL_FRACTION.",
             file=sys.stderr,
         )
         return 1
@@ -142,7 +142,7 @@ def run() -> int:
     # loss tensors. Liger's FLCE chunks the lm_head projection + loss so the full
     # logits tensor never exists. The patch is Qwen2-family-specific: for a
     # different base family, swap the matching apply_liger_kernel_to_* (or drop it
-    # and shrink SEQ_LEN/batch).
+    # and shrink BLITZ_SEQ_LEN/batch).
     apply_liger_kernel_to_qwen2()
 
     model = AutoModelForCausalLM.from_pretrained(
@@ -196,7 +196,7 @@ def run() -> int:
         bf16=True,
         logging_steps=10,
         # steps, not epoch: LoRA checkpoints are small/cheap, so frequent saves
-        # only add resilience if a long run is interrupted. Tune SAVE_STEPS once
+        # only add resilience if a long run is interrupted. Tune BLITZ_SAVE_STEPS once
         # real steps/sec is known for a ~5-10 minute cadence.
         save_strategy="steps",
         save_steps=save_steps,

{blitz_cli-0.14.0 → blitz_cli-0.15.0}/blitz_cli/cli.py

@@ -58,7 +58,7 @@ def _cmd_locker_room_init(args: argparse.Namespace) -> int:
         "\nOn-demand QLoRA training (needs a GPU; "
         f"default base model {args.base_model}):\n"
         "  blitz locker-room train      # outputs -> ./train-out\n"
-        "\nSet WORKSPACE_DIR to the code root the graph should ontologize "
+        "\nSet BLITZ_WORKSPACE_DIR to the code root the graph should ontologize "
         "(default: your home dir)."
     )
     return 0
@@ -146,10 +146,10 @@ def _cmd_execute(args: argparse.Namespace) -> int:
     if args.collect:
         import sqlite3
 
-        # Sink selection (contract C5): COLLECT_ENDPOINT set means collection
+        # Sink selection (contract C5): BLITZ_COLLECT_ENDPOINT set means collection
         # writes go over HTTP to the ingest endpoint; unset means the direct
         # SQLite path, unchanged.
-        collect_endpoint = os.environ.get("COLLECT_ENDPOINT")
+        collect_endpoint = os.environ.get("BLITZ_COLLECT_ENDPOINT")
         if collect_endpoint:
             from blitz_cli import _collect_http
 
@@ -199,10 +199,10 @@ def _cmd_collect_flush(args: argparse.Namespace) -> int:
 
     from blitz_cli import _collect_http
 
-    endpoint = args.endpoint or os.environ.get("COLLECT_ENDPOINT")
+    endpoint = args.endpoint or os.environ.get("BLITZ_COLLECT_ENDPOINT")
     if not endpoint:
         _eprint(
-            "error: no endpoint configured. Set COLLECT_ENDPOINT or pass "
+            "error: no endpoint configured. Set BLITZ_COLLECT_ENDPOINT or pass "
             "--endpoint http://host:1739."
         )
         return 2
@@ -219,7 +219,7 @@ def _cmd_collect_serve(args: argparse.Namespace) -> int:
     db = Path(args.db) if args.db else _collect.default_db_path()
     port = args.port
     if port is None:
-        port = int(os.environ.get("COLLECT_PORT", _collect_server.DEFAULT_PORT))
+        port = int(os.environ.get("BLITZ_COLLECT_PORT", _collect_server.DEFAULT_PORT))
     try:
         _collect_server.serve(db, host=args.host, port=port)
     except OSError as exc:
@@ -570,7 +570,7 @@ def build_parser() -> argparse.ArgumentParser:
     execute.add_argument(
         "--collect", action="store_true",
         help="Record every generation attempt into the activity database "
-        "(env ACTIVITY_DB_PATH, default data/activity.db). Off by default, "
+        "(env BLITZ_ACTIVITY_DB_PATH, default data/activity.db). Off by default, "
         "off means no database access.",
     )
     execute.add_argument(
@@ -589,7 +589,7 @@ def build_parser() -> argparse.ArgumentParser:
     collect = model_sub.add_parser(
         "collect",
         help="Collection sink utilities for runs recorded over the collect "
-        "ingest endpoint (COLLECT_ENDPOINT).",
+        "ingest endpoint (BLITZ_COLLECT_ENDPOINT).",
     )
     collect_sub = collect.add_subparsers(dest="collect_cmd", required=True)
 
@@ -605,7 +605,7 @@ def build_parser() -> argparse.ArgumentParser:
     )
     collect_flush.add_argument(
         "--endpoint", default=None, metavar="URL",
-        help="Ingest endpoint base URL (default: the COLLECT_ENDPOINT env var).",
+        help="Ingest endpoint base URL (default: the BLITZ_COLLECT_ENDPOINT env var).",
     )
     collect_flush.set_defaults(func=_cmd_collect_flush)
 
@@ -619,7 +619,7 @@ def build_parser() -> argparse.ArgumentParser:
     def _add_db_flag(p):
         p.add_argument(
             "--db", default=None, metavar="PATH",
-            help="Activity database path (default: ACTIVITY_DB_PATH env, "
+            help="Activity database path (default: BLITZ_ACTIVITY_DB_PATH env, "
             "else data/activity.db).",
         )
 
@@ -733,7 +733,7 @@ def build_parser() -> argparse.ArgumentParser:
         "--base-model",
         default=_scaffold._DEFAULT_LOCKER_ROOM_BASE_MODEL,
         help=f"Default base model for `blitz locker-room train` (default "
-        f"{_scaffold._DEFAULT_LOCKER_ROOM_BASE_MODEL}); override per-run with BASE_MODEL_HF.",
+        f"{_scaffold._DEFAULT_LOCKER_ROOM_BASE_MODEL}); override per-run with BLITZ_BASE_MODEL_HF.",
     )
     lr_init.set_defaults(func=_cmd_locker_room_init)
 
@@ -758,16 +758,16 @@ def build_parser() -> argparse.ArgumentParser:
         "collect-serve",
         help="Serve the collect ingest endpoint: an HTTP JSON write surface that "
         "persists DPO collection data (runs, attempts, finish markers) into "
-        "the activity database for collectors pointing COLLECT_ENDPOINT here.",
+        "the activity database for collectors pointing BLITZ_COLLECT_ENDPOINT here.",
     )
     collect_serve.add_argument(
         "--db", default=None, metavar="PATH",
-        help="Activity database path (default: ACTIVITY_DB_PATH env, "
+        help="Activity database path (default: BLITZ_ACTIVITY_DB_PATH env, "
         "else data/activity.db).",
     )
     collect_serve.add_argument(
         "--port", type=int, default=None, metavar="PORT",
-        help="Listen port (default: COLLECT_PORT env, else 1739).",
+        help="Listen port (default: BLITZ_COLLECT_PORT env, else 1739).",
     )
     collect_serve.add_argument(
         "--host", default="0.0.0.0", metavar="HOST",

{blitz_cli-0.14.0 → blitz_cli-0.15.0}/blitz_cli/playbooks/commands/implement.md

@@ -158,7 +158,7 @@ You **MUST** consider the user input before proceeding (if not empty).
         (its per-attempt replies are in `.blitz/execute/runs/<stamp>/`), mark it off,
         then resume the loop.
         `--collect` records every local attempt as DPO training data in the activity
-        database (`ACTIVITY_DB_PATH` env, else `data/activity.db` under the CWD). If the
+        database (`BLITZ_ACTIVITY_DB_PATH` env, else `data/activity.db` under the CWD). If the
         invocation fails because that database is missing or unwritable, retry once
         WITHOUT `--collect` — delegation must not be blocked by collection — and tell
         the user collection was skipped and why. When you take over a task the local

{blitz_cli-0.14.0 → blitz_cli-0.15.0}/blitz_cli/templates/locker_room_Makefile.tmpl

@@ -21,7 +21,7 @@ pull:
 up:
 	mkdir -p data
 	$(COMPOSE) up -d watch graph mcp
-	@echo "MCP server on http://localhost:$${MCP_PORT:-1738}/sse"
+	@echo "MCP server on http://localhost:$${BLITZ_MCP_PORT:-1738}/sse"
 
 down:
 	$(COMPOSE) down

{blitz_cli-0.14.0 → blitz_cli-0.15.0}/blitz_cli/templates/locker_room_README.md.tmpl

@@ -10,7 +10,7 @@ from `sparepartslabs/blitz-locker-room`). Nothing is built locally. Refresh with
 
 - **watch** — ingests coding-agent session transcripts into `data/activity.db`.
 - **graph** — rebuilds the ontology of your playbook-enabled repos/huddles/features
-  and their code lineage into `data/ontology.db` on a loop. Scans `WORKSPACE_DIR`.
+  and their code lineage into `data/ontology.db` on a loop. Scans `BLITZ_WORKSPACE_DIR`.
 - **mcp** — serves the ontology to agents over MCP (SSE) and a browser graph view.
 - **train** — on-demand QLoRA trainer (profile `train`, needs a GPU).
 
@@ -24,15 +24,15 @@ blitz locker-room train         # on-demand QLoRA (GPU); outputs -> ./train-out
 blitz locker-room down
 ```
 
-Override host paths via env, e.g. `WORKSPACE_DIR=/path/to/code blitz locker-room up`.
-Defaults: `CLAUDE_PROJECTS_DIR=$projects_dir`, `WORKSPACE_DIR=$workspace_dir`.
+Override host paths via env, e.g. `BLITZ_WORKSPACE_DIR=/path/to/code blitz locker-room up`.
+Defaults: `BLITZ_CLAUDE_PROJECTS_DIR=$projects_dir`, `BLITZ_WORKSPACE_DIR=$workspace_dir`.
 
 ## Use the node
 
 - **MCP for agents:** the `mcp` service serves SSE at
-  `http://localhost:$${MCP_PORT:-1738}/sse` — add that URL to your agent's MCP config
+  `http://localhost:$${BLITZ_MCP_PORT:-1738}/sse` — add that URL to your agent's MCP config
   (on a VPN / team host, point agents at the node's address instead of localhost).
-- **Browser graph view:** open `http://localhost:$${MCP_PORT:-1738}/graph`.
+- **Browser graph view:** open `http://localhost:$${BLITZ_MCP_PORT:-1738}/graph`.
 
 The ontology is built and served entirely by the node; there are no host-side
 `ontologize`/`list`/`mcp` commands — query it through the MCP tools or `/graph`.

{blitz_cli-0.14.0 → blitz_cli-0.15.0}/blitz_cli/templates/locker_room_compose.yml.tmpl

@@ -16,58 +16,58 @@ services:
     <<: *core
     command: ["python", "/app/watch.py"]
     volumes:
-      - "$${CLAUDE_PROJECTS_DIR:-$projects_dir}:/claude-projects:ro"
+      - "$${BLITZ_CLAUDE_PROJECTS_DIR:-$projects_dir}:/claude-projects:ro"
       - ./data:/workspace/data
     environment:
-      PROJECTS_DIR: /claude-projects
-      ACTIVITY_DB_PATH: /workspace/data/activity.db
-      WATCH_INTERVAL_SECONDS: "$${WATCH_INTERVAL_SECONDS:-$interval}"
+      BLITZ_PROJECTS_DIR: /claude-projects
+      BLITZ_ACTIVITY_DB_PATH: /workspace/data/activity.db
+      BLITZ_WATCH_INTERVAL_SECONDS: "$${BLITZ_WATCH_INTERVAL_SECONDS:-$interval}"
 
   # Rebuild the ontology (repos/huddles/features + code lineage) on a loop.
   graph:
     <<: *core
     command: ["python", "/app/ontologize.py"]
     volumes:
-      - "$${WORKSPACE_DIR:-$workspace_dir}:/repos:ro"
+      - "$${BLITZ_WORKSPACE_DIR:-$workspace_dir}:/repos:ro"
       - ./data:/workspace/data
     environment:
-      SCAN_DIR: /repos
-      ONTOLOGY_DB_PATH: /workspace/data/ontology.db
-      ONTOLOGIZE_INTERVAL_SECONDS: "$${ONTOLOGIZE_INTERVAL_SECONDS:-300}"
+      BLITZ_SCAN_DIR: /repos
+      BLITZ_ONTOLOGY_DB_PATH: /workspace/data/ontology.db
+      BLITZ_ONTOLOGIZE_INTERVAL_SECONDS: "$${BLITZ_ONTOLOGIZE_INTERVAL_SECONDS:-300}"
 
   # Serve the ontology to agents over MCP (SSE) + a /graph web view.
   mcp:
     <<: *core
     command: ["python", "/app/server.py"]
     ports:
-      - "$${MCP_PORT:-1738}:1738"
+      - "$${BLITZ_MCP_PORT:-1738}:1738"
     volumes:
       - ./data:/workspace/data:ro
     environment:
-      ONTOLOGY_DB_PATH: /workspace/data/ontology.db
-      MCP_HOST: 0.0.0.0
-      MCP_PORT: 1738
+      BLITZ_ONTOLOGY_DB_PATH: /workspace/data/ontology.db
+      BLITZ_MCP_HOST: 0.0.0.0
+      BLITZ_MCP_PORT: 1738
 
   # Receive DPO collection writes from hosts running `blitz model execute
-  # --collect` (COLLECT_ENDPOINT=http://<node>:1739) -> data/activity.db.
+  # --collect` (BLITZ_COLLECT_ENDPOINT=http://<node>:1739) -> data/activity.db.
   collect:
     <<: *core
     command: ["python", "/app/collect_serve.py"]
     ports:
-      - "$${COLLECT_PORT:-1739}:1739"
+      - "$${BLITZ_COLLECT_PORT:-1739}:1739"
     volumes:
       - ./data:/workspace/data
     environment:
-      ACTIVITY_DB_PATH: /workspace/data/activity.db
-      COLLECT_PORT: 1739
+      BLITZ_ACTIVITY_DB_PATH: /workspace/data/activity.db
+      BLITZ_COLLECT_PORT: 1739
 
   # On-demand (profile "train"): `docker compose run --rm train` / `make train`.
   train:
     image: ghcr.io/sparepartslabs/blitz-locker-room/train:latest
     profiles: ["train"]
     environment:
-      ACTIVITY_DB_PATH: /data/activity.db
-      BASE_MODEL_HF: "$${BASE_MODEL_HF:-$base_model}"
+      BLITZ_ACTIVITY_DB_PATH: /data/activity.db
+      BLITZ_BASE_MODEL_HF: "$${BLITZ_BASE_MODEL_HF:-$base_model}"
       PYTORCH_CUDA_ALLOC_CONF: expandable_segments:True
     volumes:
       - ./data:/data:ro

{blitz_cli-0.14.0 → blitz_cli-0.15.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "blitz-cli"
-version = "0.14.0"
+version = "0.15.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.14.0 → blitz_cli-0.15.0}/tests/test_cli.py

@@ -242,7 +242,7 @@ def test_collect_unwritable_db_fails_loudly_before_any_task(tmp_path, capsys, mo
     ro.mkdir()
     os.chmod(ro, stat.S_IRUSR | stat.S_IXUSR)
     db = ro / "activity.db"
-    monkeypatch.setenv("ACTIVITY_DB_PATH", str(db))
+    monkeypatch.setenv("BLITZ_ACTIVITY_DB_PATH", str(db))
     try:
         args = cli.build_parser().parse_args(
             ["model", "execute", "--repo", str(tmp_path), "--collect"]

{blitz_cli-0.14.0 → blitz_cli-0.15.0}/tests/test_collect.py

@@ -145,9 +145,9 @@ def test_check_writable_raises_on_unwritable_path(tmp_path):
 
 
 def test_default_db_path_env_override(monkeypatch):
-    monkeypatch.delenv("ACTIVITY_DB_PATH", raising=False)
+    monkeypatch.delenv("BLITZ_ACTIVITY_DB_PATH", raising=False)
     assert _collect.default_db_path() == __import__("pathlib").Path("data/activity.db")
-    monkeypatch.setenv("ACTIVITY_DB_PATH", "/tmp/other.db")
+    monkeypatch.setenv("BLITZ_ACTIVITY_DB_PATH", "/tmp/other.db")
     assert str(_collect.default_db_path()) == "/tmp/other.db"
 
 

{blitz_cli-0.14.0 → blitz_cli-0.15.0}/tests/test_collect_http.py

@@ -1,5 +1,5 @@
 """Tests for the client side of the collect ingest endpoint: sink selection
-via COLLECT_ENDPOINT, the HttpCollectSink (fail fast at run start, row parity
+via BLITZ_COLLECT_ENDPOINT, the HttpCollectSink (fail fast at run start, row parity
 with the direct path, mid-run buffering), and the buffer flush command.
 Specs: specs/005-collect-ingest-endpoint/."""
 
@@ -65,7 +65,7 @@ def test_check_writable_ok_against_live_server(tmp_path):
 
 def test_cmd_execute_fails_fast_with_unreachable_endpoint(tmp_path, monkeypatch, capsys):
     repo, tasks_file = _repo_with_tasks(tmp_path)
-    monkeypatch.setenv("COLLECT_ENDPOINT", "http://127.0.0.1:9")
+    monkeypatch.setenv("BLITZ_COLLECT_ENDPOINT", "http://127.0.0.1:9")
     rc = cli.main(["model", "execute", str(tasks_file), "--repo", str(repo),
                    "--collect"])
     assert rc == 1
@@ -92,7 +92,7 @@ def test_endpoint_env_selects_http_sink(tmp_path, monkeypatch):
     repo, tasks_file = _repo_with_tasks(tmp_path)
     srv, thread, base = _start_server(tmp_path / "a.db")
     try:
-        monkeypatch.setenv("COLLECT_ENDPOINT", base)
+        monkeypatch.setenv("BLITZ_COLLECT_ENDPOINT", base)
         seen = _capture_collector(monkeypatch)
         rc = cli.main(["model", "execute", str(tasks_file), "--repo", str(repo),
                        "--collect"])
@@ -105,8 +105,8 @@ def test_endpoint_env_selects_http_sink(tmp_path, monkeypatch):
 
 def test_env_unset_selects_direct_store(tmp_path, monkeypatch):
     repo, tasks_file = _repo_with_tasks(tmp_path)
-    monkeypatch.delenv("COLLECT_ENDPOINT", raising=False)
-    monkeypatch.setenv("ACTIVITY_DB_PATH", str(tmp_path / "direct.db"))
+    monkeypatch.delenv("BLITZ_COLLECT_ENDPOINT", raising=False)
+    monkeypatch.setenv("BLITZ_ACTIVITY_DB_PATH", str(tmp_path / "direct.db"))
     seen = _capture_collector(monkeypatch)
     rc = cli.main(["model", "execute", str(tasks_file), "--repo", str(repo),
                    "--collect"])
@@ -288,16 +288,16 @@ def test_flush_stops_on_unreachable_endpoint_and_keeps_file(tmp_path):
 
 
 def test_flush_cli_requires_an_endpoint(tmp_path, monkeypatch, capsys):
-    monkeypatch.delenv("COLLECT_ENDPOINT", raising=False)
+    monkeypatch.delenv("BLITZ_COLLECT_ENDPOINT", raising=False)
     buf = tmp_path / "collect-buffer.jsonl"
     buf.write_text("")
     rc = cli.main(["model", "collect", "flush", str(buf)])
     assert rc == 2
-    assert "COLLECT_ENDPOINT" in capsys.readouterr().err
+    assert "BLITZ_COLLECT_ENDPOINT" in capsys.readouterr().err
 
 
 def test_flush_cli_errors_on_missing_file(monkeypatch, capsys, tmp_path):
-    monkeypatch.setenv("COLLECT_ENDPOINT", "http://127.0.0.1:9")
+    monkeypatch.setenv("BLITZ_COLLECT_ENDPOINT", "http://127.0.0.1:9")
     rc = cli.main(["model", "collect", "flush", str(tmp_path / "nope.jsonl")])
     assert rc == 2
     assert "no buffer file" in capsys.readouterr().err
@@ -307,7 +307,7 @@ def test_flush_cli_delivers_via_env_endpoint(tmp_path, monkeypatch, capsys):
     _, _, buffer_path, db = _run_with_midrun_server_death(tmp_path)
     srv, thread, base = _start_server(db)
     try:
-        monkeypatch.setenv("COLLECT_ENDPOINT", base)
+        monkeypatch.setenv("BLITZ_COLLECT_ENDPOINT", base)
         rc = cli.main(["model", "collect", "flush", str(buffer_path)])
         assert rc == 0
         assert "flushed 2 record(s)" in capsys.readouterr().out

{blitz_cli-0.14.0 → blitz_cli-0.15.0}/tests/test_scaffold.py

@@ -133,11 +133,11 @@ def test_render_locker_room_compose_substitutes_default_paths(tmp_path):
     _scaffold.render_locker_room(out, interval=45)
     compose = (out / "docker-compose.yml").read_text()
     # overridable host paths keep a concrete default baked at scaffold time
-    assert "${CLAUDE_PROJECTS_DIR:-" in compose
+    assert "${BLITZ_CLAUDE_PROJECTS_DIR:-" in compose
     assert "/.claude/projects}:/claude-projects:ro" in compose
-    assert "${WORKSPACE_DIR:-" in compose
+    assert "${BLITZ_WORKSPACE_DIR:-" in compose
     assert ":/repos:ro" in compose
-    assert "${WATCH_INTERVAL_SECONDS:-45}" in compose
+    assert "${BLITZ_WATCH_INTERVAL_SECONDS:-45}" in compose
 
 
 def test_render_locker_room_readme_and_gitignore(tmp_path):