deviatdd 2.21.2__tar.gz → 2.23.0__tar.gz

deviatdd-2.23.0/.deviate/config.toml

@@ -0,0 +1,20 @@
+# Preset config group: "default", "full", "fast", or "secure"
+profile = "default"
+# CLI inactivity timeout in seconds (must be > 0)
+timeout_seconds = 1800
+# Agent export mode: "local" (project) or "global" (~/.claude/)
+agent_export_mode = "local"
+# Enable the libref CLI for offline documentation lookups
+use_libref = true
+# Trunk branch for worktrees, PR base, and review diffs
+base_branch = "main"
+# Push the claim branch as a distributed lock (default true)
+claim_remote = true
+
+# Agent backend configuration
+
+[agent]
+backend = "pi"
+timeout = 600
+pi_rpc = false
+transport = "rpc"

deviatdd-2.23.0/.github/workflows/release.yml

@@ -0,0 +1,86 @@
+name: Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      bump:
+        description: SemVer bump (auto from conventional commits, or explicit)
+        required: false
+        default: auto
+        type: choice
+        options:
+          - auto
+          - patch
+          - minor
+          - major
+      dry_run:
+        description: Print the computed version and skip commit, tag, and publish
+        required: false
+        default: false
+        type: boolean
+
+permissions:
+  contents: write
+  id-token: write
+
+jobs:
+  release:
+    name: Cut and publish
+    runs-on: ubuntu-latest
+    steps:
+      - name: Refuse non-default branch unless dry_run
+        if: ${{ github.ref_name != github.event.repository.default_branch && inputs.dry_run != true }}
+        run: |
+          echo "Refusing to release from '${GITHUB_REF_NAME}'."
+          echo "Default branch is '${{ github.event.repository.default_branch }}'."
+          echo "Re-run with dry_run=true to preview, or run from the default branch."
+          exit 1
+
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          ref: ${{ github.ref }}
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.13"
+
+      - name: Compute next version
+        id: version
+        run: |
+          set -euo pipefail
+          VERSION="$(uv run --no-project python scripts/next_version.py --bump "${{ inputs.bump }}")"
+          echo "version=${VERSION}" >> "${GITHUB_OUTPUT}"
+          echo "Computed next version: ${VERSION}"
+
+      - name: Dry run complete
+        if: ${{ inputs.dry_run == true }}
+        run: |
+          echo "dry_run=true — skipping commit, tag, and publish for ${{ steps.version.outputs.version }}"
+
+      - name: Apply version bump
+        if: ${{ inputs.dry_run != true }}
+        run: |
+          set -euo pipefail
+          uv run --no-project python scripts/next_version.py --bump "${{ inputs.bump }}" --write
+
+      - name: Commit, tag, and push
+        if: ${{ inputs.dry_run != true }}
+        run: |
+          set -euo pipefail
+          VERSION="${{ steps.version.outputs.version }}"
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add pyproject.toml uv.lock
+          git commit -m "chore(release): version ${VERSION}"
+          git tag "v${VERSION}"
+          git push origin "HEAD:${GITHUB_REF_NAME}"
+          git push origin "v${VERSION}"
+
+      - name: Publish to PyPI
+        if: ${{ inputs.dry_run != true }}
+        run: |
+          set -euo pipefail
+          uv build
+          uv publish --trusted-publishing always

{deviatdd-2.21.2 → deviatdd-2.23.0}/CHANGELOG.md

@@ -8,6 +8,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
+- **On-demand GitHub Actions Release workflow (`workflow_dispatch`).** A maintainer runs Actions → Release → Run workflow. The job computes the next SemVer from conventional commits since the current `pyproject.toml` version (`feat` → minor, `fix` → patch, `BREAKING CHANGE` / `feat!` / `fix!` → major; chore/docs/test/ci/style/refactor still bump patch), writes `pyproject.toml` + the `deviatdd` version in `uv.lock`, commits `chore(release): version X.Y.Z` on the default branch, tags `vX.Y.Z`, and publishes with `uv build` / `uv publish --trusted-publishing always` (PyPI trusted publishing via GitHub OIDC; `contents: write` + `id-token: write`; no `PYPI_API_TOKEN` and no GitHub secret). Optional inputs: `bump` (`auto` / `patch` / `minor` / `major`) and `dry_run` (print the version; skip commit/tag/publish). Refuses a non-default branch unless `dry_run` is true. Does not rewrite `CHANGELOG.md` (stays `[Unreleased]`). Operator adds a pending PyPI trusted publisher for `wernerbisschoff/deviatdd` workflow `release.yml` (no environment). Local fallback remains `mise run publish`. Pinned by `tests/test_release/test_next_version.py`.
+- **COMPLETED `tasks.jsonl` rows now persist runner-validated JUDGE evidence (GH-84).** After the #65 mechanical gate accepts a TDD completion path (`skip_refactor` / bare `COMPLIANCE_PASS` / post-REFACTOR complete / adjudicated already-exists), `_append_status_transition(..., "COMPLETED")` copies `HandoverManifest.evidence` (`ac`, `test_path`, `test_quote`, `impl_path`, `impl_quote`) onto an optional `TaskRecord.evidence` bundle and stamps `red` (`session.red_commit_sha`) plus `green`/`head` (`HEAD` at the write). TDD complete fail-closes when the plan contract has `AC-PLAN-NNN` tokens and the bundle is missing or does not cover them (`evaluate_judge_evidence`, no new matcher). EXECUTE / IMMEDIATE / DIRECT stay ungated; enabling/infra plans with no AC tokens may complete with empty evidence. `deviate inspect tasks show` prints the field when present. Session files are not the proof store. Pinned by `tests/test_micro/test_completed_evidence.py`, `tests/test_state/test_ledger.py`, and `tests/test_cli/test_inspect.py`.
+- **`deviate micro run --review` pauses before each phase commit (GH-101).** After the agent finishes a phase and tests/lint have run, `--review` (and `--all --review`) halt before `_commit_phase` / `_commit_phase_with_recovery` (`git add -A`), print `REVIEW_PAUSE <phase> <task_id>`, leave the worktree dirty for herdr/hunk, and wait for TTY confirmation (`Enter` / yes). Then the runner commits as today and continues. Pause applies to RED, GREEN, REFACTOR, and EXECUTE — not JUDGE feedback commits. RED is still committed before GREEN so `session.red_commit_sha` remains available for JUDGE `revert_to_red`. Non-TTY / `--json` / missing stdin fail closed with `REVIEW_REQUIRES_TTY` and never auto-commit past the flag. Off by default; no config key. The pause is one helper (`_maybe_review_pause`) in front of `_commit_phase`, not a copy in each phase. Pinned by `tests/test_micro/test_review_pause.py`.
+- **`deviate judge post [<manifest>]` applies JUDGE revert + train feedback in manual mode (GH-104).** `/deviate-judge` already told the agent to run `deviate judge post` after the verdict, but only `judge pre` existed — manual mode printed the verdict and left GREEN (or RED+GREEN) in place. The new command reads the JUDGE handover (path or stdin YAML), coerces `next_action` with the same helpers auto uses (`_coerce_judge_action`, unmatched-PASS rewrite, GREEN TEST_FAILURE remap), then applies auto's side effects through `_apply_judge_verdict`: `revert_to_red` / `revert_before` reuse `_execute_rollback` / `_resolve_pre_red_sha`; train feedback is appended to the task card and committed by `_commit_judge_feedback_and_advance`; forward routes do not reset. Rejection without actionable feedback is `JUDGE_AGENT_NO_FEEDBACK`; a missing RED boundary on `revert_to_red` stays fatal. Auto `micro run` still calls `_run_judge_phase` and does not shell out to the new CLI. Overlay step 3 now names revert + `tasks.md` feedback + commit. Pinned by `tests/test_micro/test_judge.py::TestJudgePost`.
 - **`/deviate-pr` now marks the issue COMPLETED before it pushes, and opens a PR/MR only on request.** Rewritten to mirror `/deviate-merge`: `deviate pr run` appends the COMPLETED transition to `specs/issues.jsonl`, stages and commits it with the PR body, pushes the branch, then opens a GitHub PR (`gh pr create`) or a GitLab MR (`git push -o merge_request.create`). Platform is auto-detected from the `origin` remote hostname. `--no-pr` pushes and marks COMPLETED without opening anything; `--merge` / `--auto-merge` apply to GitHub only (GitLab warns and opens for review). `--platform github|gitlab` forces the platform. Pinned by `tests/test_integration/test_meso_layer.py::TestPrRun` and `tests/test_meso/test_pr_platform.py`.
 - **Graphite CLI integration is removed from the active code, prompts, and specs.** The `--graphite` setup flag, the `graphite` config field and `resolve_graphite_config`, the `gt create` / `gt submit` routing in `feature.py` / `micro.py` / `meso.py`, and the `## Graphite Stacked Changes Workflow` governance seed are gone. `deviate pr` no longer has a Graphite path (`git push -o merge_request.create` covers GitLab). Historical spec archives (`specs/adhoc/007-graphite-cli`, `specs/003-graphite-cli-integration`) and the append-only ledgers are left untouched.
 - **Manual slash-command bodies now derive from the canonical `auto/{phase}.md` core at install time.** `install_command`/`compose_command_body` (`src/deviate/core/commands.py`) splice the canonical `auto/{phase}.md` middle verbatim for the 11 overlapping phases (explore, research, prd, shard, plan, tasks, red, green, refactor, judge, execute) plus a per-phase manual overlay (pre/post-script lifecycle, rich handover manifest, `<context><user_input>`). The hand-maintained duplicate middle bodies were deleted from `commands/deviate-{phase}.md`, so the manual and auto modes can no longer drift. The derived RED inherits auto's `status: "PASS"` + `failure_kind` semantics (no `status: "FAIL"`/abort-on-passing-test); the derived GREEN inherits auto's "write ONLY production code" role language. A drift guard pins the identical-middle invariant across all 11 phases. Pinned by `tests/test_core/test_commands.py::TestManualDerivationFromAutoCore` and `tests/test_meso/test_auto_prompt_templates.py::TestManualDerivationDriftGuard`.
@@ -27,6 +31,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **`deviate html prd --bucket <slug>` targets a specific epic when more than one owns a `prd.md`.** Previously the command hard-failed with `HTML_AMBIGUOUS_PRD` whenever multiple numbered epics had a `prd.md` and offered no flag to disambiguate — the agent was told to "run from within the epic's worktree", which silently yielded `HTML_NO_PRD` because the resolver reads `specs/` from the repo root. The new option resolves `specs/<bucket>/prd.md` directly and bypasses ambiguity detection; the plain form keeps its existing behavior but its ambiguity banner now points at the flag. An unknown/absent bucket exits `PRD_NOT_FOUND`. The `/deviate-html` prompt (`src/deviate/prompts/commands/deviate-html.md`) and spec docs now reference `--bucket` instead of the broken cwd fallback. Pinned by `tests/test_cli/test_html.py::test_html_prd_bucket_targets_specific_epic`, `::test_html_prd_bucket_targets_unnumbered_dir`, and `::test_html_prd_bucket_missing_file_exits_cleanly`.
 - **Optional push-as-lock: `claim_remote` config plus `--local` on `meso run` and `run`.** Standing `.deviate/config.toml` key `claim_remote` defaults to `true` (absent file or absent key still push). `deviate setup --no-claim-remote` writes `claim_remote = false` without dropping `[models]`, `timeout_seconds`, or `[agent]`. Fresh setup without the flag writes `true`. Effective local mode is `--local` OR `claim_remote = false`; explicit `--local` always wins. Local mode still creates `.worktrees/feat/{epic}/{issue}/`, writes SPECIFIED, and commits the claim, and skips `branch_exists_on_remote` plus `git push`. `deviate specify --local` stays; omitted `--local` now honors config. `deviate meso run --local` and `deviate run --local` share that meaning. `--no-setup` remains a distinct skip of worktree plus claim. Local discovery does not treat an origin branch as claimed-elsewhere. Specs: `specs/DeviaTDD-api.md`, `specs/DeviaTDD-architecture.md` (Atomic Concurrency Protocol: push-as-lock is the default, not mandatory). Pinned by `tests/test_state/test_config.py`, `tests/test_cli/test_meso.py`, `tests/test_meso/test_specify.py`, `tests/test_meso/test_meso_orchestration.py`, `tests/test_cli/test_init.py`, and `tests/test_cli/test_top_level_run.py`.
 ### Changed
+- **The `deviatdd` skill checks for an existing OPEN GitHub issue before filing a harness-bug issue.** The "Filing deviatdd issues" section now runs `gh issue list --repo wernerbisschoff/deviatdd --state open --search` first; when an open issue already matches the same harness failure, it directs commenting the new evidence/task context onto that issue (`gh issue comment`) instead of `gh issue create`, and only creates a new issue when no match exists. Prompt-only change to the packaged skill (`src/deviate/prompts/skills/deviatdd/SKILL.md`), re-installed to all agent skill dirs.
 - **`deviate refactor pre` now scopes `files_to_refactor` to the RED+GREEN production set (GH-98).** The command no longer glob()s every `src/**/*.py` or discards `_resolve_task_context`. It lists production files from `HEAD~2..HEAD`, falling back to the task `Files:` list minus tests when that git range is empty or unavailable. Test files are never included. The JSON contract now emits the documented handover fields (`status`, `task_id`, `task_title`, `task_type`, `test_command`, `lint_command`, `spec_dir`, `verification`, `repo_root`, `git_branch`, `timestamp`) alongside `files_to_refactor`. Auto `_build_auto_prompt("refactor")` injects the same scoped list and keeps the `git log -2` / `git diff HEAD~2..HEAD` inspect step. Pinned by `tests/test_micro/test_refactor.py`.
 - **GREEN / REFACTOR / review prompts fold smallest-change into existing lines** (reuse stdlib or an already-installed dep; in-place refactor; Opportunities do not extract helpers). Prompt-only. Pinned by `tests/test_meso/test_auto_prompt_templates.py::TestSmallestChangeFoldedIntoExistingPrompts`.
 - **JUDGE evidence is task-scoped; `deviate review` fail-closes on an unclaimed plan AC.** TDD `_run_judge_phase` resolves required `AC-PLAN-NNN` tokens via `resolve_task_ac_tokens` (non-empty `acceptance_criteria` `criterion_id`s, else this task's `tasks.md` card, else none) and does not fall back to every token in `plan.md`. ISS-ADH-020 exact-substring, path-in-diff, and uniqueness-floor checks still apply to that set. EXECUTE, IMMEDIATE, and DIRECT stay ungated. `deviate review pre` / `post` run a runner-owned Gate 3 scan (`evaluate_review_coverage`) and exit non-zero with `COVERAGE_INCOMPLETE` when any this-issue plan token has no COMPLETED claim. Missing `plan.md` or missing plan tokens stay vacuously READY. PENDING, FAILED, and sibling-issue rows do not claim. Pinned by `tests/test_core/test_judge_evidence.py`, `tests/test_micro/test_judge.py`, and `tests/test_cli/test_review.py`.
@@ -50,6 +55,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **`/deviate-merge` no longer auto-pushes after the squash-merge commit; the push gate runs inline and the network push is opt-in.** The slash command previously ran `git push` as its final step. As of v2.4.0 the squash-merge commit lands on `main`, then a new `push_gate` step inlines the body of `.githooks/pre-push` (lint + format-check + testmon-driven affected tests with the warm-cache / full-suite fallback — bash 3.2 portable, `GIT_DIR` reset + trap preserved) so the safety net fires even though no `git push` happens yet. After the gate passes the skill asks the operator whether to `git push` (which fires the real `pre-push` hook and re-runs the same gate) or stop and push manually. The squash-merge commit and the ledger transition inside it are durable on `main` regardless of the push outcome — only the network push is deferred. New failure states: `Push_Gate_Failed` (inline gate non-zero), `Push_Failed` (`git push` non-zero, raw stderr surfaced), `Push_Deferred` (user chose "Stop — I'll push manually"). Inline gate body and `.githooks/pre-push` body must stay byte-equivalent; divergence is pinned by `tests/test_meso/test_auto_prompt_templates.py::TestMergePromptPushGate::test_hook_and_prompt_agree_on_gate_body` (which compares non-blank non-comment lines in both bodies and fails on drift in either direction) plus 3 supporting assertions on the upstream-first logic, the testmon fallback, and the prompt structure. Prompt: `src/deviate/prompts/commands/deviate-merge.md` (v2.3.0 → v2.4.0). Spec mirrors updated: `specs/DeviaTDD-architecture.md` (Merge bullet, new `**Push gate + opt-in push (v2.4.0)**` sub-bullet) and `specs/DeviaTDD-api.md` (new `**/deviate-merge push behavior (v2.4.0)**` entry under the `deviate merge` reference).
 
 ### Fixed
+- **JUDGE prompt injection now uses the Judge-Feedback-stripped task card (GH-118).** `_build_auto_prompt("judge")` still reads the raw card via `_task_card_text`, then applies the same `_strip_judge_feedback` pass that `resolve_task_ac_tokens` already used for token resolution (#89). Prior-round `**Judge Feedback**` bullets and their continuation lines (including false ownership claims such as "AC-PLAN-003 belongs to a later task") no longer appear in `<task_card>`. Token resolution, `_append_judge_feedback`, and the COMPLETED evidence gate are unchanged. Specs: `specs/DeviaTDD-api.md`, `specs/DeviaTDD-architecture.md`. Pinned by `tests/test_micro/test_judge.py::TestJudgePromptStripsJudgeFeedback`.
+- **Ledger appenders no longer concatenate a new JSONL record onto a last line that lacks a trailing newline (GH-117).** `_append_record` and `_append_with_compound_key` insert a leading `\n` when the file is non-empty and does not already end in a newline, so `_read_ledger` cannot skip a fused BACKLOG+SPECIFIED line. `claim_issue` now writes through `append_issue_transition` instead of a raw `"a"` append. Pinned by `tests/test_state/test_ledger.py` and `tests/test_core/test_issues.py`.
+- **JUDGE handover parse now recovers unescaped `"` inside evidence quote fields (GH-116).** `AgentBackend.parse_output` retries `yaml.safe_load` after rewriting broken `quote` / `test_quote` / `impl_quote` double-quoted scalars as `|` block scalars, so citations such as `assert "YAGNI" in text` and `== ["AC-PLAN-002"]` no longer raise `MalformedHandoverManifestError`. Well-formed YAML is unchanged. The auto judge prompt also prefers `|` block scalars when a quote contains `"`. Pinned by `tests/test_core/test_agent.py`.
+- **A `no_failing_test` already-exists JUDGE `COMPLIANCE_PASS` now completes via `skip_refactor` instead of hard-crashing with `ROLLBACK_BOUNDARY_MISSING`.** On the RED `no_failing_test` adjudication route (`session.failure_kind == "no_failing_test"`, `session.red_commit_sha == ""`), `_apply_judge_verdict` coerces any PASS `next_action` to `skip_refactor` through `_NO_FAILING_TEST_FORWARD_ROUTES`, skips the unmatched-PASS AC-token citation rewrite, and relaxes only the `COMPLETED_EVIDENCE_MISSING` token check for that route — the declared-regression-files gate (`_require_tdd_declared_regression_files`) stays fail-closed, a wrong test still routes to `revert_before` for RED re-author, and a genuine test-bearing RED with a real RED commit still rolls back via `revert_to_red`. Previously every retry crashed because the mechanical gate rewrote the pass to `revert_to_red` with no RED commit to roll back to. Specs updated: `specs/DeviaTDD-api.md`, `specs/DeviaTDD-architecture.md`. Pinned by `tests/test_micro/test_judge.py` and `tests/test_cli/test_micro.py`.
+- **Feature worktrees now base on the local trunk, so locally-authored (unpushed) issues plan without failing.** `resolve_start_point` (`src/deviate/core/worktree.py`) previously preferred `origin/<base>` over local `<base>`, so a `deviate meso run` that discovered an issue committed only to local `main` created its worktree from a stale `origin/main` that lacked the issue's `specs/issues.jsonl` row and source file — the plan agent wrote `plan.md`, then `deviate plan post` failed with `ISSUE_NOT_FOUND <IDS>` and exited 1. Meso reads the issue ledger from the local trunk, so the worktree base now comes from local `<base>` first (falling back to `origin/<base>`, then `HEAD`). Pinned by `tests/test_core/test_worktree.py::TestCreateWorktree::test_resolve_start_point_prefers_local_base_over_stale_origin`.
+- **`deviate meso run` / `deviate specify` auto-discovery now skips issues already claimed locally.** A claim writes the issue's `BACKLOG → SPECIFIED` ledger row in the new worktree and commits it on the `feat/{epic}/{issue}` feature branch, so the main checkout's `specs/issues.jsonl` still shows the issue as `BACKLOG`. `_discover_claimable_issue` therefore re-returned the same first issue to a second terminal on the same checkout (parallel run) instead of claiming a different one; the origin-branch lock only caught issues whose claim branch had been `git push`-ed. Discovery now also skips a candidate whose `feat/{epic}/{issue}` branch already has a local worktree (treated as claimed here), in both local and default mode, mirroring the signal `_try_claim_issue` already uses for `ALREADY_CLAIMED_LOCAL`. Two terminals on one checkout can now claim two different BACKLOG issues in parallel. Pinned by `tests/test_meso/test_meso_orchestration.py::TestDiscoverClaimableIssue::test_skips_issues_with_local_worktree`.
+- **`_append_judge_feedback` writes under the rejected task card, and the evidence gate keeps judge `train_feedback` / `violations` (GH-102).** The appender locates the card with `_TASK_BULLET_HEAD_RE` exact-id match (same regex as `_read_judge_feedback_from_tasks_md`) and stops at the next task or a `##` / `###` phase heading, so a Phase 1 `TSK-004-01` rejection no longer drops `**Judge Feedback**` under the next phase `### Tasks` / `TSK-004-02`. When the evidence gate rewrites unmatched PASS, persist the judge's own `train_feedback` / `violations` (after the GH-103 citation strip) instead of replacing them with the generic `JUDGE evidence is missing...` string. Pinned by `tests/test_micro/test_judge.py::TestJudgeFeedbackLogging::test_append_judge_feedback_stays_under_rejected_card_across_phase_header` and `TestTddJudgeEvidenceGate::test_rewritten_pass_keeps_judge_train_feedback` / `::test_rewritten_pass_keeps_judge_violations`.
+- **JUDGE injected diff walks past docs-feedback `red_commit_sha` to the real RED commit (GH-88, GH-90).** `_maybe_advance_red_sha_past_feedback` still advances the session SHA onto `docs(...): add judge feedback for retry` so GREEN entry and `revert_to_red` keep a valid TRAIN boundary. `_assemble_judge_injected_diff` now resolves the diff base via `_resolve_judge_diff_base`, walking back through those feedback subjects to the RED-phase failing-test commit and running `git diff {red_sha}^..HEAD`. The evidence gate no longer false-rejects with `test_path is not in the injected diff` or missing AC tokens solely because the RED test dropped out of a docs-only range. Pinned by `tests/test_micro/test_judge.py::TestJudgeDiffBaseWalksPastFeedback`.
 - **`resolve_task_ac_tokens` no longer treats runner-appended `**Judge Feedback**` as required AC tokens (GH-89).** Card-text fallback still follows first-hit order (`acceptance_criteria` `criterion_id`s, else the task card, else none) but now drops `**Judge Feedback**` bullets and their continuation lines before scanning for `AC-PLAN-NNN`. A feedback line quoting `AC-PLAN-001` does not add that token when the card body does not name it. `_task_card_text` still returns the full card. Pinned by `tests/test_core/test_judge_evidence.py::TestResolveTaskAcTokens::test_judge_feedback_quote_does_not_add_token`.
 - **JUDGE revert-route `train_feedback` no longer persists discarded `file:line` citations (GH-103).** After `revert_before` / `revert_to_red`, `_judge_feedback_from_manifest` strips `path:line` tokens before writing `session.train_feedback` and `tasks.md`. The durable rewrite contract ("The next RED/GREEN attempt must: …") stays. Rollback SHA selection is unchanged. Auto judge prompt also forbids line citations on those routes. Pinned by `tests/test_micro/test_judge.py::TestRevertFeedbackStripsLineCitations`.
 - **`deviate micro run` now honors `[agent].timeout` from the worktree `.deviate/config.toml` (GH-87).** `_invoke_agent` previously constructed `AgentConfig(backend=...)` with the 600s default, so long GREEN runs died with `AGENT_TIMEOUT` even when the operator set `timeout = 1800`. Meso already read the same key. Unset or invalid values still default to 600. Pinned by `tests/test_cli/test_micro.py::TestInvokeAgentConfigTimeout`.

{deviatdd-2.21.2 → deviatdd-2.23.0}/CONTRIBUTING.md

@@ -258,10 +258,34 @@ do require the same traceability.
 
 ## Release process (for maintainers)
 
-1. Update `CHANGELOG.md` — move `[Unreleased]` bullets into a dated
-   `[X.Y.Z]` section.
-2. Bump `version` in `pyproject.toml`.
-3. `git tag -s vX.Y.Z -m "Release vX.Y.Z"` (signed tag).
-4. `git push origin main --follow-tags`.
-5. CI publishes to PyPI via trusted publishing once the workflow is
-   enabled.
+Leave `CHANGELOG.md` under `## [Unreleased]`. The Release workflow does
+not rewrite the changelog (tests pin bullets there).
+
+1. On PyPI, add a **pending trusted publisher** for project `deviatdd`
+   ([Publishing → Trusted publishers](https://pypi.org/manage/account/publishing/)):
+   - Owner / org: `wernerbisschoff`
+   - Repository: `deviatdd`
+   - Workflow: `release.yml`
+   - Environment: leave empty (this workflow does not use a GitHub
+     Environment)
+   The first successful `uv publish` from that workflow promotes the
+   pending publisher. No GitHub secret is required.
+2. On GitHub, open **Actions → Release → Run workflow** on the default
+   branch (`main`).
+   - `bump`: `auto` (default) computes the next SemVer from conventional
+     commits since the commit that set the current `pyproject.toml`
+     version (`feat` → minor, `fix` → patch, `BREAKING CHANGE` /
+     `feat!` / `fix!` → major). Only `chore` / `docs` / `test` / `ci` /
+     `style` / `refactor` still bumps patch so a manual cut always
+     produces a new version. Choose `patch` / `minor` / `major` to
+     force a level.
+   - `dry_run`: print the computed version and skip commit, tag, and
+     publish. Dry-run is allowed from a non-default branch; a real cut
+     is not.
+3. The job writes `version = "X.Y.Z"` in `pyproject.toml` and the
+   matching `name = "deviatdd"` version in `uv.lock`, commits
+   `chore(release): version X.Y.Z` on the ref the workflow ran on,
+   tags `vX.Y.Z`, pushes commit + tag, then runs `uv build` and
+   `uv publish --trusted-publishing always` (GitHub OIDC; no token).
+4. Local fallback (no bump, no tag): `mise run publish` still builds
+   and uploads using `PYPI_API_TOKEN` from `.env`.

{deviatdd-2.21.2 → deviatdd-2.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: deviatdd
-Version: 2.21.2
+Version: 2.23.0
 Summary: DeviaTDD CLI — agent orchestration framework
 Project-URL: Homepage, https://github.com/wernerbisschoff/deviatdd
 Project-URL: Repository, https://github.com/wernerbisschoff/deviatdd

{deviatdd-2.21.2 → deviatdd-2.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deviatdd"
-version = "2.21.2"
+version = "2.23.0"
 description = "DeviaTDD CLI — agent orchestration framework"
 readme = "README.md"
 license = "MIT"

deviatdd-2.23.0/scripts/next_version.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+"""Compute the next SemVer for an on-demand GitHub Actions release cut.
+
+Reads the current ``version`` from ``pyproject.toml``, inspects conventional
+commits since the commit that set that version (falling back to the latest
+``v*`` tag, then the previous ``chore(release):`` commit), and prints the
+next ``X.Y.Z`` on stdout.
+
+Bump rules (highest wins):
+
+- ``BREAKING CHANGE`` / ``feat!:`` / ``fix!:`` → major
+- ``feat:`` → minor
+- ``fix:`` → patch
+- only ``chore`` / ``docs`` / ``test`` / ``ci`` / ``style`` / ``refactor``
+  → patch (a manual cut still produces a new version)
+- no conventional commits since the baseline → patch
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+_TYPES = ("feat", "fix", "chore", "docs", "test", "ci", "style", "refactor")
+_SUBJECT_RE = re.compile(
+    rf"^(?:(?P<type>{'|'.join(_TYPES)})"
+    rf"(?P<scope>\([^)]*\))?(?P<breaking>!)?:"
+    rf")\s",
+    re.IGNORECASE,
+)
+_BREAKING_RE = re.compile(r"BREAKING[ -]CHANGE", re.IGNORECASE)
+_PYPROJECT_VERSION_RE = re.compile(
+    r'^version\s*=\s*["\']([^"\']+)["\']\s*$',
+    re.MULTILINE,
+)
+_LOCK_VERSION_RE = re.compile(
+    r'(name = "deviatdd"\nversion = ")[^"]+(")',
+)
+_RELEASE_SUBJECT_RE = r"^chore\(release\): version "
+_RANK = {"major": 3, "minor": 2, "patch": 1}
+
+
+def git_env() -> dict[str, str]:
+    """Strip GIT_*/GH_* so subprocess git never inherits a parent repo."""
+    return {
+        k: v
+        for k, v in os.environ.items()
+        if not k.startswith("GIT_") and not k.startswith("GH_")
+    }
+
+
+def _git(*args: str, repo: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["git", *args],
+        cwd=repo,
+        env=git_env(),
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+
+def read_current_version(pyproject: Path) -> str:
+    text = pyproject.read_text(encoding="utf-8")
+    match = _PYPROJECT_VERSION_RE.search(text)
+    if match is None:
+        raise SystemExit(f"version not found in {pyproject}")
+    return match.group(1)
+
+
+def bump_semver(version: str, level: str) -> str:
+    try:
+        major_s, minor_s, patch_s = version.split(".")
+        major, minor, patch = int(major_s), int(minor_s), int(patch_s)
+    except ValueError as exc:
+        raise SystemExit(f"not a X.Y.Z version: {version!r}") from exc
+    if level == "major":
+        return f"{major + 1}.0.0"
+    if level == "minor":
+        return f"{major}.{minor + 1}.0"
+    if level == "patch":
+        return f"{major}.{minor}.{patch + 1}"
+    raise SystemExit(f"unknown bump level: {level!r}")
+
+
+def classify_commit(message: str) -> str | None:
+    if _BREAKING_RE.search(message):
+        return "major"
+    subject = message.split("\n", 1)[0].strip()
+    match = _SUBJECT_RE.match(subject)
+    if match is None:
+        return None
+    if match.group("breaking"):
+        return "major"
+    commit_type = match.group("type").lower()
+    if commit_type == "feat":
+        return "minor"
+    if commit_type == "fix":
+        return "patch"
+    if commit_type in {"chore", "docs", "test", "ci", "style", "refactor"}:
+        return "patch"
+    return None
+
+
+def highest_bump(messages: list[str]) -> str:
+    rank = 0
+    for message in messages:
+        level = classify_commit(message)
+        if level is None:
+            continue
+        rank = max(rank, _RANK[level])
+    if rank == 0:
+        return "patch"
+    for name, value in _RANK.items():
+        if value == rank:
+            return name
+    return "patch"
+
+
+def _pickaxe_version_commit(repo: Path, version: str) -> str | None:
+    needle = f'version = "{version}"'
+    result = subprocess.run(
+        ["git", "log", "-1", "--format=%H", "-S", needle, "--", "pyproject.toml"],
+        cwd=repo,
+        env=git_env(),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    sha = result.stdout.strip()
+    return sha or None
+
+
+def _latest_v_tag(repo: Path) -> str | None:
+    result = subprocess.run(
+        ["git", "tag", "-l", "v*", "--sort=-v:refname"],
+        cwd=repo,
+        env=git_env(),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    for line in result.stdout.splitlines():
+        tag = line.strip()
+        if tag:
+            return tag
+    return None
+
+
+def _latest_release_commit(repo: Path) -> str | None:
+    result = subprocess.run(
+        [
+            "git",
+            "log",
+            "-1",
+            "--extended-regexp",
+            f"--grep={_RELEASE_SUBJECT_RE}",
+            "--format=%H",
+        ],
+        cwd=repo,
+        env=git_env(),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    sha = result.stdout.strip()
+    return sha or None
+
+
+def find_version_baseline(repo: Path, current_version: str) -> str:
+    for candidate in (
+        _pickaxe_version_commit(repo, current_version),
+        _latest_v_tag(repo),
+        _latest_release_commit(repo),
+    ):
+        if candidate:
+            return candidate
+    raise SystemExit(
+        "could not determine version baseline "
+        "(no pyproject version commit, v* tag, or chore(release) commit)"
+    )
+
+
+def commits_since(repo: Path, baseline: str) -> list[str]:
+    result = _git("log", f"{baseline}..HEAD", "--format=%B%x1e", repo=repo)
+    return [block.strip() for block in result.stdout.split("\x1e") if block.strip()]
+
+
+def compute_next_version(repo: Path, bump: str = "auto") -> str:
+    pyproject = repo / "pyproject.toml"
+    current = read_current_version(pyproject)
+    if bump != "auto":
+        return bump_semver(current, bump)
+    baseline = find_version_baseline(repo, current)
+    level = highest_bump(commits_since(repo, baseline))
+    return bump_semver(current, level)
+
+
+def persist_version(repo: Path, version: str) -> None:
+    pyproject = repo / "pyproject.toml"
+    text = pyproject.read_text(encoding="utf-8")
+    updated, count = _PYPROJECT_VERSION_RE.subn(f'version = "{version}"', text, count=1)
+    if count != 1:
+        raise SystemExit(f"failed to write version in {pyproject}")
+    pyproject.write_text(updated, encoding="utf-8")
+
+    lock = repo / "uv.lock"
+    if not lock.is_file():
+        raise SystemExit(f"uv.lock not found at {lock}")
+    lock_text = lock.read_text(encoding="utf-8")
+    lock_updated, lock_count = _LOCK_VERSION_RE.subn(
+        rf"\g<1>{version}\2", lock_text, count=1
+    )
+    if lock_count != 1:
+        raise SystemExit(f'failed to write name = "deviatdd" version in {lock}')
+    lock.write_text(lock_updated, encoding="utf-8")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--repo",
+        type=Path,
+        default=Path.cwd(),
+        help="repository root (default: cwd)",
+    )
+    parser.add_argument(
+        "--bump",
+        choices=("auto", "patch", "minor", "major"),
+        default="auto",
+        help="bump level (default: auto from conventional commits)",
+    )
+    parser.add_argument(
+        "--write",
+        action="store_true",
+        help="persist the computed version to pyproject.toml and uv.lock",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="print the computed version and skip all writes",
+    )
+    args = parser.parse_args(argv)
+
+    repo = args.repo.resolve()
+    version = compute_next_version(repo, bump=args.bump)
+    print(version)
+    if args.dry_run:
+        print(f"dry_run: next version is {version} (no files written)", file=sys.stderr)
+        return 0
+    if args.write:
+        persist_version(repo, version)
+        print(f"wrote {version} to pyproject.toml and uv.lock", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())