teddy-cli 0.1.17.dev1275__tar.gz → 0.1.17.dev1276__tar.gz

{teddy_cli-0.1.17.dev1275 → teddy_cli-0.1.17.dev1276}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: teddy-cli
-Version: 0.1.17.dev1275
+Version: 0.1.17.dev1276
 Summary: A local-first, file-based AI coding workflow that applies the UNIX philosophy to AI collaboration.
 Author: Raphael Atteritano
 License: AGPL-3.0-only

{teddy_cli-0.1.17.dev1275 → teddy_cli-0.1.17.dev1276}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "teddy-cli"
-version = "0.1.17.dev1275"
+version = "0.1.17.dev1276"
 description = "A local-first, file-based AI coding workflow that applies the UNIX philosophy to AI collaboration."
 authors = [{ name = "Raphael Atteritano" }]
 license = { text = "AGPL-3.0-only" }

{teddy_cli-0.1.17.dev1275 → teddy_cli-0.1.17.dev1276}/src/teddy_executor/resources/MRP.xml

@@ -50,7 +50,8 @@ NOTES:
       2. Commit Message: Use Conventional Commits `'<type>(<scope>): <description>'` in single quotes (imperative mood; append `!` for breaking changes) on a single line.
       3. Execution: Run `make commit '<type>(<scope>): <description>'`. This stages all local changes (`git add .`) and runs Git's local hooks before committing.
       4. Post-conditions: All tests MUST pass: the post-commit hook reverts automatically on failure and cannot be bypassed.
-      5. Push at Conclusion: In the Conclusion phase, run `make push` to rebase, push, and inspect CI: use `make logs <run-id> '<step-name>'` for full logs. If blocking test failures occur, fix them immediately, commit, and push again. For non-blocking quality gate results, address directly if localized, or record them in the roadmap in `docs/project/PROJECT.md` if not already planned.
+      5. Push at Conclusion: In the Conclusion phase, run `make push` to rebase and push.
+      6. If needed: to verify remote CI run `make ci-watch` to monitor workflow runs and to inspect results: use `make logs <run-id> '<step-name>'` for full logs.
     </rule>
 
     <rule n="7" name="Standardized Plan Types">

{teddy_cli-0.1.17.dev1275 → teddy_cli-0.1.17.dev1276}/src/teddy_executor/resources/config/prompts/architect.xml

@@ -35,7 +35,7 @@
       <phase n="4" name="Conclusion">
         <goal>Clean up the workspace, commit changes, push, and hand off to the next agent.</goal>
         <step n="1" name="Cleanup">Delete temporary files, scratchpads, and diagnostic notes.</step>
-        <step n="2" name="Commit and Push">Execute `make commit`, then run `make push` and inspect CI results</step>
+        <step n="2" name="Commit and Push">Execute `make commit`, then run `make push`.</step>
         <step n="3" name="Handoff">Message the user with instructions to start the next session, including the new Vertical Slice as a reference file. Route to the Prototyper if the slice contains unresolved Key Unknowns; otherwise route directly to the Developer.</step>
       </phase>
     </workflow>

{teddy_cli-0.1.17.dev1275 → teddy_cli-0.1.17.dev1276}/src/teddy_executor/resources/config/prompts/developer.xml

@@ -110,7 +110,7 @@
 
       <phase n="7" name="Conclusion">
         <goal>Finalize remote synchronization and dynamically route the next session handoff.</goal>
-        <step n="1" name="Remote Sync">Run `make push` to push commits and inspect CI results. If blocking test failures occur, fix them immediately, commit, and push again. For non-blocking quality gate issues, address them if contained or record them in the roadmap in `docs/project/PROJECT.md`.</step>
+        <step n="1" name="Remote Sync">Run `make push` to push commits, then run `make ci-watch` to monitor and inspect remote CI results. If blocking test failures occur, fix them immediately, commit, and push again. For non-blocking quality gate issues, address them if contained or record them in the roadmap in `docs/project/PROJECT.md`.</step>
         <step n="2" name="Handoff">Message the user to route the next session based on milestone state: the Architect if the next slice is un-designed, the Prototyper if it has unresolved Key Unknowns, the Developer if ready to implement, or the Pathfinder if all milestone slices are complete.</step>
       </phase>
     </workflow>

{teddy_cli-0.1.17.dev1275 → teddy_cli-0.1.17.dev1276}/src/teddy_executor/resources/templates/ARCHITECTURE.md

@@ -17,7 +17,7 @@ This section defines foundational engineering practices. Each entry MUST be a sp
 - **CI Pipeline:** Two parallel jobs — 1) Blocking OS matrix test suite with strict test coverage targets. 2) Non-blocking (continue-on-error: true) quality checks running fast formatters, linters, security/secret scanners, type checkers, and repository-wide structural checks (excluding sandboxes and third-party dependencies).
 - **Pre-commit Hooks:** Scope (staged files only) and keep the local loop fast — formatters, secret scanners, and merge-conflict checks only. Move heavy, false-positive-prone checks (type checkers, security scanners, repository-wide structural checkers) to the non-blocking CI quality job, scoped to a non-default pre-commit stage.
 - **Post-commit Execution:** Full test suite run on commit, automatic revert on failure.
-- **Makefile Commands:** The `Makefile` is the canonical entry point for the VCP commit workflow and on-demand test runs. `make test` runs the full suite, `make commit '<msg>'` performs a LOCAL-ONLY VCP commit (it runs the pre-commit hooks once as an advisory auto-fix pass and commits WITHOUT `--no-verify`, so Git's own pre-commit hook is the real local gate, while the post-commit test gate remains unskippable), `make push` rebases, pushes, and reports CI results back (deferred to the session Conclusion), and `make probe '<reason>'` runs the Remote Probing Protocol. See [docs/templates/makefile.md](docs/templates/makefile.md).
+- **Makefile Commands:** The `Makefile` is the canonical entry point for the VCP commit workflow and on-demand test runs. `make test` runs the full suite, `make commit '<msg>'` performs a LOCAL-ONLY VCP commit (it runs the pre-commit hooks once as an advisory auto-fix pass and commits WITHOUT `--no-verify`, so Git's own pre-commit hook is the real local gate, while the post-commit test gate remains unskippable), `make push` rebases and pushes, `make ci-watch` watches remote CI and reports results (used by Developer at slice conclusion), and `make probe '<reason>'` runs the Remote Probing Protocol. See [docs/templates/makefile.md](docs/templates/makefile.md).
 
 ### Pre-commit Quick-Start
 

{teddy_cli-0.1.17.dev1275 → teddy_cli-0.1.17.dev1276}/src/teddy_executor/resources/templates/PROJECT.md

@@ -25,7 +25,7 @@ Defines the high-level artifact lifecycle and conventions for project management
 - **Archiving Policy:** When and how completed artifacts are archived or deleted.
 - **Spec Organization:** Specification documents live in a single flat directory `docs/project/specs/` and are reserved strictly for **permanent system invariants** — formats, contracts, protocols (e.g. the MRP), core data models, and non-negotiable architectural rules. Feature goals, requirements, and acceptance criteria belong in Milestone documents (`docs/project/milestones/`), not in specs. There is no ephemeral `specs/features/` lifecycle.
 - **Run Environment:** Specify the project's designated environment/dependency manager (e.g., `uv`, `poetry`, `pip`) and prefix ALL execution commands with its runner (e.g., `uv run pytest`). The chosen runner MUST be reflected in the `Makefile`.
-- **Build & Run Commands:** Document the standard commands in the project `Makefile` (see [docs/templates/makefile.md](docs/templates/makefile.md)). At minimum: `make test` (full suite), `make commit '<msg>'` (VCP), and `make probe '<reason>'` (Remote Probing Protocol).
+- **Build & Run Commands:** Document the standard commands in the project `Makefile` (see [docs/templates/makefile.md](docs/templates/makefile.md)). At minimum: `make test` (full suite), `make commit '<msg>'` (VCP), `make push`, `make ci-watch` (CI monitoring), and `make probe '<reason>'` (Remote Probing Protocol).
 - **Release Process:** Document how releases are cut. At minimum: (1) **Triage** the scope (patch/minor/major) from conventional commits since the last tag; (2) write **release notes** to `docs/project/releases/v<version>.md`; (3) bump the `version` field in the project manifest; (4) present the notes and version bump at an **approval gate**; (5) **commit** (`chore(release): bump version to <version>`) and **tag** (`git tag -a v<version>`); and (6) **publish** (e.g. create a GitHub Release). Adapt the concrete commands to the project's packaging and distribution channel.
 
 ## Templates

{teddy_cli-0.1.17.dev1275 → teddy_cli-0.1.17.dev1276}/src/teddy_executor/resources/templates/makefile.md

@@ -13,13 +13,21 @@ make commit 'feat(templates): add PROJECT.md template'
 ```
 
 **What is `.PHONY`?**
-`.PHONY` is a Makefile directive that declares `commit`, `push`, `probe`, `test`, and `logs` as phony targets — they do not correspond to actual files. Without `.PHONY`, if a file named `commit` or `probe` existed in the directory (e.g., a script called `commit`), Make would see it as up-to-date and skip the target entirely. By declaring them phony, Make always runs the recipe when you call `make commit`, `make push`, `make probe`, or `make test`.
+`.PHONY` is a Makefile directive that declares `commit`, `push`, `ci-watch`, `probe`, `test`, and `logs` as phony targets — they do not correspond to actual files. Without `.PHONY`, if a file named `commit` or `probe` existed in the directory (e.g., a script called `commit`), Make would see it as up-to-date and skip the target entirely. By declaring them phony, Make always runs the recipe when you call `make commit`, `make push`, `make ci-watch`, `make probe`, or `make test`.
 
 ### Push
 ```shell
 make push
 ```
 
+### CI Watch
+```shell
+make ci-watch
+```
+
+**What does `make ci-watch` do?**
+`make ci-watch` resolves the commit hash from `HEAD` (or an explicit `COMMIT=<sha>`), polls GitHub Actions to allow for workflow registration lag, watches all running workflows for that commit, prints failing step details, and attributes regressions. It is used by the Developer at slice conclusion to verify remote CI without slowing down routine pushes.
+
 ### Test
 ```shell
 make test
@@ -128,7 +136,21 @@ commit:
 
 ## Push (Deferred to Conclusion)
 
-`make push` runs `git pull --rebase`, captures the base and the pushed SHA, pushes, then discovers **every** CI run for the pushed SHA (`gh run list --commit <sha>`) and waits for and reports each workflow with its jobs. It answers ONE question: **did this push turn a BLOCKING gate red?**
+`make push` is fast and non-blocking: it runs `git pull --rebase` and pushes local commits to remote.
+
+### Example
+
+```makefile
+push:
+	git pull --rebase
+	git push
+```
+
+**Usage:** `make push`
+
+## CI Watch & Attribution
+
+`make ci-watch` discovers **every** CI run for the target commit (`HEAD` by default, or `COMMIT=<sha>`), waits for and reports each workflow with its jobs. It answers ONE question: **did this commit turn a BLOCKING gate red?**
 
 The pushed RUN's own conclusion is authoritative: it already folds in `continue-on-error`, so a **non-blocking** job (e.g. the CI `Quality Checks` job) can NEVER block the session — it is reported as a triage item instead. Only when the run-level conclusion is `failure` does attribution run, comparing the pushed run's failing-JOB set against the base run's:
 
@@ -141,24 +163,22 @@ When any step fails — blocking or not — the target prints the failing step's
 
 Attribution is deterministic: SHA → run → run-level + per-job conclusion (never "the latest run").
 
-Three behaviors make the attribution trustworthy:
+Key behaviors:
 
-1. **The base is captured BEFORE the push.** `BASE=$$(git rev-parse origin/main)` is read immediately after `git pull --rebase` and before `git push`; otherwise the push advances `origin/main` and `BASE` collapses onto the pushed SHA, making every comparison trivially equal (a real regression would be silently misclassified as pre-existing). `git push` is folded into the same shell block behind `|| exit $$?` so a rejected push still aborts the target.
-2. **Registration lag is tolerated by a bounded retry.** CI may not have registered a run for the pushed SHA yet; the target polls `gh run list --commit <sha>` up to `RETRY_POLLS × RETRY_SLEEP` (default 10 × 1s ≈ 10s) before attributing, then fails safe if the run never registers.
-3. **No CI is non-blocking.** If the repository has no workflow files under `.github/workflows/` (`*.yml`/`*.yaml`), the target logs `No CI configured - skipping attribution` and exits 0 — a CI-less repo is never blocked. This is distinct from a repo WITH CI whose pushed SHA registered no run (that still fail-safe blocks).
+1. **Automatic SHA and BASE resolution.** `SHA` defaults to current `HEAD` (or `COMMIT=<sha>`), and `BASE` defaults to `HEAD~1`.
+2. **Registration lag is tolerated by a bounded retry.** CI may not have registered a run for the pushed SHA immediately; the target polls `gh run list --commit <sha>` up to `RETRY_POLLS × RETRY_SLEEP` (default 10 × 2s ≈ 20s) before attributing, then fails safe if the run never registers.
+3. **No CI is non-blocking.** If the repository has no workflow files under `.github/workflows/` (`*.yml`/`*.yaml`), the target logs `No CI configured - skipping attribution` and exits 0.
 
 ### Example
 
 ```makefile
 RETRY_POLLS ?= 10
-RETRY_SLEEP ?= 1
+RETRY_SLEEP ?= 2
 DETAIL_LINES ?= 50
 
-push:
-	git pull --rebase
-	@BASE=$$(git rev-parse origin/main); \
-	SHA=$$(git rev-parse HEAD); \
-	git push || exit $$?; \
+ci-watch:
+	@SHA=$$(git rev-parse $${COMMIT:-HEAD}); \
+	BASE=$$(git rev-parse $${COMMIT:-HEAD}~1 2>/dev/null || echo ""); \
 	if [ -z "$$(ls .github/workflows/*.yml .github/workflows/*.yaml 2>/dev/null)" ]; then \
 	  echo "No CI configured - skipping attribution"; \
 	  exit 0; \
@@ -170,9 +190,9 @@ push:
 	  ATTEMPTS=$$((ATTEMPTS + 1)); \
 	  sleep $(RETRY_SLEEP); \
 	done; \
-	echo "Pushed $$SHA (base $$BASE) after $$ATTEMPTS poll(s)"; \
+	echo "Watching CI for $$SHA (base $${BASE:-none}) after $$ATTEMPTS poll(s)"; \
 	if [ -z "$$WFS" ]; then \
-	  echo "CI: no run registered for $$SHA after $(RETRY_POLLS) poll(s) - fail-safe block"; \
+	  echo "CI: no run registered for $$SHA after $$(( $(RETRY_POLLS) * $(RETRY_SLEEP) ))s - fail-safe block"; \
 	  exit 1; \
 	fi; \
 	for WF in $$WFS; do \
@@ -194,6 +214,10 @@ push:
 	    fi; \
 	    continue; \
 	  fi; \
+	  if [ -z "$$BASE" ]; then \
+	    echo "$$WF: BLOCKING failure ($$NEWFAIL) — no base commit — YOUR regression"; \
+	    STATUS=1; continue; \
+	  fi; \
 	  OLD=$$(gh run list --commit "$$BASE" --workflow "$$WF" --json databaseId --jq '.[0].databaseId'); \
 	  if [ -z "$$OLD" ]; then \
 	    echo "$$WF: BLOCKING failure ($$NEWFAIL) — base has no run (unknown base) — YOUR regression"; \
@@ -215,7 +239,9 @@ push:
 	exit $$STATUS
 ```
 
-**Usage:** `make push`
+**Usage:**
+- `make ci-watch` (watches CI for current `HEAD`)
+- `make ci-watch COMMIT=<sha>` (watches CI for a specific commit)
 
 ## Remote Probing Protocol (RPP)
 
@@ -273,4 +299,5 @@ logs:
 - Post-commit hook lives at `.githooks/post-commit.py` and runs the full `uv run pytest` suite.
 - Ensure `gh` (GitHub CLI) is authenticated for `make push`, the Remote Probing Protocol, and CI Log Extraction.
 - The `make logs` target abstracts the Debugger's CI-log extraction (Phase 1, Step 2). See [CI Log Extraction](#ci-log-extraction).
-- `make push` runs in the session Conclusion phase (see [Push (Deferred to Conclusion)](#push-deferred-to-conclusion)); it rebases, pushes, and reports CI results back.
+- `make push` runs in the session Conclusion phase (see [Push (Deferred to Conclusion)](#push-deferred-to-conclusion)); it rebases and pushes.
+- `make ci-watch` monitors and attributes CI results for `HEAD` or an explicit commit (see [CI Watch & Attribution](#ci-watch--attribution)).