steerdev 1.1.28__tar.gz → 1.1.31__tar.gz

{steerdev-1.1.28 → steerdev-1.1.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerdev
-Version: 1.1.28
+Version: 1.1.31
 Summary: Backend task runner for steerdev.com - orchestrates CLI coding agents with activity reporting
 Project-URL: Homepage, https://github.com/pentoai/steerdev-agent
 Project-URL: Repository, https://github.com/pentoai/steerdev-agent

{steerdev-1.1.28 → steerdev-1.1.31}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerdev"
-version = "1.1.28"
+version = "1.1.31"
 description = "Backend task runner for steerdev.com - orchestrates CLI coding agents with activity reporting"
 readme = "README.md"
 authors = [

steerdev-1.1.31/src/steerdev_agent/git/__init__.py

@@ -0,0 +1 @@
+"""Git helpers for the steerdev runtime."""

steerdev-1.1.31/src/steerdev_agent/git/commit.py

@@ -0,0 +1,96 @@
+"""Deterministic per-task boundary commit for wave runs.
+
+After each successful task in wave mode, the runner commits everything
+outstanding with a task-scoped message, so the wave branch ends up with one
+clean commit per task regardless of how the agent chose to commit (or didn't).
+
+All functions are best-effort and never raise — a commit failure must never
+break the run. Async, mirroring `workspace.preparation._run_git`.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING, Any
+
+from loguru import logger
+
+from steerdev_agent.git_ops import PROTECTED_BRANCHES
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def build_task_commit_message(task: dict[str, Any]) -> str:
+    """Build a task-scoped commit message.
+
+    Prefix precedence mirrors `worktree.compute_branch_name`:
+    - external ticket ID (`linear_identifier`, then `external_id`) → `[PROJ-123]`
+    - otherwise the first 8 chars of the internal id → `[task:abc12345]`
+
+    The task title is appended when present.
+    """
+    external_id = task.get("linear_identifier") or task.get("external_id")
+    if external_id:
+        prefix = f"[{external_id}]"
+    else:
+        task_id = task.get("id", "unknown")
+        short = task_id[:8] if len(task_id) > 8 else task_id
+        prefix = f"[task:{short}]"
+
+    title = (task.get("title") or "").strip()
+    return f"{prefix} {title}" if title else prefix
+
+
+async def _run_git(cwd: str | Path, *args: str) -> tuple[int, str]:
+    """Run git, returning (returncode, stdout+stderr). Never raises for git errors."""
+    proc = await asyncio.create_subprocess_exec(
+        "git",
+        *args,
+        cwd=str(cwd),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout_bytes, stderr_bytes = await proc.communicate()
+    out = (stdout_bytes.decode("utf-8", errors="replace") or "").strip()
+    err = (stderr_bytes.decode("utf-8", errors="replace") or "").strip()
+    return proc.returncode or 0, out or err
+
+
+async def commit_task_boundary(cwd: str | Path, task: dict[str, Any]) -> str:
+    """Stage and commit everything outstanding as one task-scoped commit.
+
+    Best-effort; never raises. Returns one of:
+        "committed", "nothing_to_commit", "skipped_protected", "failed".
+    """
+    try:
+        # Resolve current branch; skip protected branches and detached/non-repo.
+        rc, branch = await _run_git(cwd, "rev-parse", "--abbrev-ref", "HEAD")
+        if rc != 0 or not branch or branch == "HEAD":
+            logger.info("commit_task_boundary: not on a branch, skipping")
+            return "failed"
+        if branch in PROTECTED_BRANCHES:
+            logger.info(f"commit_task_boundary: protected branch {branch}, skipping")
+            return "skipped_protected"
+
+        rc, _ = await _run_git(cwd, "add", "-A")
+        if rc != 0:
+            logger.warning("commit_task_boundary: git add failed (non-fatal)")
+            return "failed"
+
+        # Anything staged? `diff --cached --quiet` exits 1 when there are changes.
+        rc, _ = await _run_git(cwd, "diff", "--cached", "--quiet")
+        if rc == 0:
+            return "nothing_to_commit"
+
+        message = build_task_commit_message(task)
+        rc, out = await _run_git(cwd, "commit", "-m", message)
+        if rc != 0:
+            logger.warning(f"commit_task_boundary: commit failed (non-fatal): {out}")
+            return "failed"
+
+        logger.info(f"commit_task_boundary: committed on {branch}: {message}")
+        return "committed"
+    except Exception as exc:  # broad catch intentional: durability must never break the run
+        logger.warning(f"commit_task_boundary: unexpected error (non-fatal): {exc}")
+        return "failed"

{steerdev-1.1.28 → steerdev-1.1.31}/src/steerdev_agent/prompt/builder.py

@@ -28,6 +28,10 @@ class WaveContext(BaseModel):
     wave_description: str = Field(default="", description="Description of this wave")
     wave_tasks_summary: str = Field(default="", description="Summary of tasks in this wave")
     completed_waves_summary: str = Field(default="", description="Summary of completed waves")
+    predecessor_branch: str | None = Field(
+        default=None,
+        description="Branch of the previous completed wave to stack this wave on",
+    )
 
 
 class TaskContext(BaseModel):

{steerdev-1.1.28 → steerdev-1.1.31}/src/steerdev_agent/runner.py

@@ -29,6 +29,8 @@ from steerdev_agent.config.models import (
 from steerdev_agent.executor import ExecutorFactory
 from steerdev_agent.executor.base import AgentExecutor, EventType, StreamEvent
 from steerdev_agent.executor.claude import ClaudeExecutorError
+from steerdev_agent.git.commit import commit_task_boundary
+from steerdev_agent.git_ops import checkpoint_push
 from steerdev_agent.prompt.builder import (
     ProjectContext,
     PromptBuilder,
@@ -108,6 +110,15 @@ def build_wave_context(wave_response: dict[str, Any]) -> WaveContext | None:
     ]
     completed_summary = "\n".join(completed_lines) if completed_lines else ""
 
+    # Stacked-wave base: the server sends the previous completed wave's branch
+    # NAME (never a number — the wave name IS the branch). A blank/absent name
+    # means no valid predecessor, so we leave the base unset and cut from default.
+    predecessor_branch: str | None = None
+    predecessor = wave_info.get("predecessor_wave")
+    if predecessor:
+        name = (predecessor.get("name") or "").strip()
+        predecessor_branch = name or None
+
     return WaveContext(
         wave_number=wave_info.get("wave_number", 1),
         total_waves=wave_info.get("total_waves", 1),
@@ -115,6 +126,7 @@ def build_wave_context(wave_response: dict[str, Any]) -> WaveContext | None:
         wave_description=wave_info.get("description", ""),
         wave_tasks_summary=tasks_summary,
         completed_waves_summary=completed_summary,
+        predecessor_branch=predecessor_branch,
     )
 
 
@@ -200,6 +212,27 @@ async def _get_modified_files(working_dir: str | Path) -> list[str]:
         return []
 
 
+async def maybe_commit_task_boundary(
+    working_dir: str | Path,
+    task: dict[str, Any],
+    wave_context: WaveContext | None,
+    dry_run: bool,
+) -> None:
+    """Commit a wave task's work at its completion boundary, then checkpoint-push.
+
+    Only fires in wave mode (single-task mode keeps the agent-driven,
+    one-PR-per-task flow). Best-effort: `commit_task_boundary` and
+    `checkpoint_push` never raise. Pushes only when a commit was actually made,
+    so the wave branch lands on origin for the next wave to stack on.
+    """
+    if dry_run or wave_context is None:
+        return
+
+    result = await commit_task_boundary(working_dir, task)
+    if result == "committed":
+        checkpoint_push(working_dir)
+
+
 def compute_worktree_name(task_id: str, wave_context: WaveContext | None = None) -> str:
     """Compute the git worktree name for a task execution.
 
@@ -924,6 +957,14 @@ class Runner:
                     except Exception:
                         logger.debug("Failed to report modified files", exc_info=True)
 
+            # Deterministic per-task commit boundary (wave mode only): commit
+            # everything outstanding as one task-scoped commit and checkpoint-push,
+            # so the wave branch has one clean commit per task and lands on origin
+            # for the next wave to stack on. No-op in single-task/dry-run mode.
+            await maybe_commit_task_boundary(
+                effective_working_dir, task, wave_context, self.dry_run
+            )
+
             if self._evidence_config.enabled and not self.dry_run:
                 await self._submit_evidence_report(
                     task=task,
@@ -1072,6 +1113,13 @@ class Runner:
                         else:
                             logger.warning(f"Failed to mark task {task_id} as completed")
 
+            # Deterministic per-task commit boundary (wave mode only; successful
+            # tasks only). See execute_task for rationale.
+            if success:
+                await maybe_commit_task_boundary(
+                    effective_working_dir, task, wave_context, self.dry_run
+                )
+
             if self._evidence_config.enabled and not self.dry_run:
                 await self._submit_evidence_report(
                     task=task,

{steerdev-1.1.28 → steerdev-1.1.31}/src/steerdev_agent/setup/templates/skills/steerdev-wave-tasks-merge-skill/SKILL.md

@@ -31,15 +31,7 @@ git checkout -b wave/<wave-number>
 2. For each task in the wave:
 - Mark the task `started`
 - Implement the requested change
-- Commit with a task-prefixed conventional commit. **Use the external ticket ID when available** (e.g. Linear ID), falling back to the internal short ID:
-
-```bash
-# With external ticket ID (preferred):
-git commit -m "[PROJ-123] feat: add user endpoint"
-
-# Fallback (no external ID):
-git commit -m "[task:abc12345] feat: add user endpoint"
-```
+- **Do not commit.** The steerdev runtime automatically commits each task's work at the task boundary with a task-prefixed message (`[PROJ-123] <title>`, or `[task:abc12345] <title>` when there is no external ID) and pushes the wave branch. You just implement; the runtime owns the per-task commit.
 
 3. After the wave work is ready for review, rebase onto the latest default branch:
 
@@ -77,25 +69,49 @@ git merge-tree --write-tree origin/<default-branch> HEAD
 steerdev git pr --title "Wave <N>: <description>" --body "..."
 ```
 
+**Do not pass `--base`.** `steerdev git pr` sets the PR base automatically from
+the task's recorded base branch. For a stacked wave (a wave that builds on a
+previous wave of the same PRD) the base is the predecessor wave's branch, so the
+PR shows only this wave's diff. Overriding `--base` would break the stack.
+
 5. Update all related tasks with the shared PR URL
 6. Log progress and completion in the root `docs/` progress files
 
-## Commit Prefix Convention
+## Commit Convention (handled by the runtime)
 
-Use external ticket IDs in commits so GitHub integrations can link commits to issues:
+You do **not** commit task work yourself. The steerdev runtime commits each task
+automatically at its completion boundary, using an external-ticket-ID-prefixed
+message so GitHub integrations can link commits to issues:
 
 | Has External ID? | Commit Prefix | Example |
 |---|---|---|
-| Yes | `[<TICKET-ID>]` | `[PROJ-123] feat: add user endpoint` |
-| No  | `[task:<short-uuid>]` | `[task:abc12345] feat: add user endpoint` |
+| Yes | `[<TICKET-ID>]` | `[PROJ-123] <task title>` |
+| No  | `[task:<short-uuid>]` | `[task:abc12345] <task title>` |
 
-Run `steerdev tasks get TASK_ID` to find the task's `linear_identifier` before committing.
+It also pushes the wave branch after each commit. Your job is to implement and,
+once the wave is done, rebase and open the PR (steps 3–5).
+
+## Stacked waves (same PRD)
+
+Waves of one PRD are **stacked**: wave-2 is branched off wave-1, wave-3 off
+wave-2, and so on. The CLI handles this for you — it cuts the wave branch off the
+previous wave's branch and records that branch as the PR base. As a result:
+
+- Each wave still gets its own PR, but its diff shows only that wave's changes.
+- The PRs form a chain: `wave-1 → default`, `wave-2 → wave-1`, `wave-3 → wave-2`.
+- **Do not delete a wave's branch until the next wave's PR has merged.** When
+  wave-1's PR merges into the default branch, GitHub automatically retargets
+  wave-2's PR — but only if wave-1's branch still exists.
+- The first wave of a PRD (and any wave with no completed same-PRD predecessor)
+  is cut from the default branch as usual.
 
 ## Conventions
 
 - Use one branch per wave: `wave/<wave-number>`
+- Do not commit task work — the runtime commits and pushes each task automatically
 - Do not create per-task PRs inside the wave
-- Keep commits traceable by including the external ticket ID (or internal ID fallback) in each commit
+- Do not pass `--base` to `steerdev git pr` — the base is set automatically
+- Do not delete wave branches until the dependent wave's PR has merged
 - Include the shared PR URL in every related task result
 - Replace `<default-branch>` in commands above with the actual branch name from the Git Branch Configuration section
 
@@ -105,18 +121,15 @@ Run `steerdev tasks get TASK_ID` to find the task's `linear_identifier` before c
 git checkout -b wave/3
 
 steerdev tasks update task-aaa... --status started
-# Check: steerdev tasks get task-aaa... → Linear ID: PROJ-123
-# ... implement task 1 ...
-git add .
-git commit -m "[PROJ-123] feat: add user endpoint"
+# ... implement task 1 ... (runtime commits "[PROJ-123] <title>" at the boundary)
 
 steerdev tasks update task-bbb... --status started
-# Check: steerdev tasks get task-bbb... → Linear ID: PROJ-124
-# ... implement task 2 ...
-git add .
-git commit -m "[PROJ-124] fix: validate email format"
+# ... implement task 2 ... (runtime commits "[PROJ-124] <title>" at the boundary)
 
-git push -u origin HEAD
+# Wave done: rebase onto the default branch (see step 3), then open one PR.
+git fetch origin <default-branch>
+git rebase origin/<default-branch>
+git push --force-with-lease origin HEAD
 steerdev git pr --title "Wave 3: User management improvements" --body "..."
 steerdev tasks update task-aaa... --result "PR: https://github.com/org/repo/pull/42"
 steerdev tasks update task-bbb... --result "PR: https://github.com/org/repo/pull/42"

{steerdev-1.1.28 → steerdev-1.1.31}/src/steerdev_agent/workspace/preparation.py

@@ -347,38 +347,91 @@ class WorkspacePreparation:
         # 4. Fetch from origin
         await _run_git("fetch", "origin", cwd=cwd, check=False)
 
-        # 5. Sync to default branch
-        rc, _, _ = await _run_git("checkout", default_branch, cwd=cwd, check=False)
-        if rc != 0:
-            return PreparationResult(
-                success=False,
-                branch_name=target_branch,
-                working_directory=cwd,
-                default_branch=default_branch,
-                is_worktree=False,
-                error=f"Failed to checkout {default_branch}. Does the branch exist?",
-            )
-
-        # Try fast-forward merge
-        rc, _, _ = await _run_git(
-            "merge", "--ff-only", f"origin/{default_branch}", cwd=cwd, check=False
-        )
-        if rc != 0:
-            # Fallback: hard reset to origin
-            logger.warning(f"Fast-forward merge failed for {default_branch}, resetting to origin")
-            await _run_git("reset", "--hard", f"origin/{default_branch}", cwd=cwd, check=False)
-            warnings.append(
-                f"Fast-forward failed, reset {default_branch} to origin/{default_branch}"
+        # 5. Resolve the base this wave stacks on. For a new wave with a
+        # predecessor (stacked-wave mode), branch directly off the predecessor's
+        # remote branch so the wave physically contains the previous wave's work.
+        # If that branch is missing from origin (never pushed / deleted), the
+        # chain is broken — fall back to the default branch and surface a loud
+        # warning rather than silently building on the wrong base.
+        predecessor_branch = wave_context.predecessor_branch if wave_context else None
+        effective_base = default_branch
+        if predecessor_branch:
+            rc, _, _ = await _run_git(
+                "rev-parse", "--verify", f"origin/{predecessor_branch}", cwd=cwd, check=False
             )
+            if rc == 0:
+                effective_base = predecessor_branch
+            else:
+                logger.warning(
+                    f"Predecessor branch origin/{predecessor_branch} missing — "
+                    f"stacked-wave chain broken; cutting {target_branch} from "
+                    f"{default_branch} instead"
+                )
+                warnings.append(
+                    f"Predecessor branch '{predecessor_branch}' not found on origin; "
+                    f"stacked-wave chain broken — cut from '{default_branch}'. This wave "
+                    f"may not contain the previous wave's work."
+                )
 
-        # 6. Create or checkout target branch
+        # 6. Create or checkout the target (wave) branch.
         rc, _, _ = await _run_git("rev-parse", "--verify", target_branch, cwd=cwd, check=False)
         branch_exists = rc == 0
 
         if branch_exists:
-            await _run_git("checkout", target_branch, cwd=cwd)
+            # Branch already present locally (e.g. a continuing wave on a fresh
+            # clone): just switch to it.
+            rc, _, _ = await _run_git("checkout", target_branch, cwd=cwd, check=False)
+            if rc != 0:
+                return PreparationResult(
+                    success=False,
+                    branch_name=target_branch,
+                    working_directory=cwd,
+                    default_branch=default_branch,
+                    is_worktree=False,
+                    error=f"Failed to checkout existing branch {target_branch}",
+                )
             logger.info(f"Switched to existing branch: {target_branch}")
+        elif effective_base != default_branch:
+            # Stacked cut: branch straight off the predecessor's remote branch.
+            # No default-branch sync — the predecessor already carries the work.
+            rc, _, _ = await _run_git(
+                "checkout", "-b", target_branch, f"origin/{effective_base}", cwd=cwd, check=False
+            )
+            if rc != 0:
+                return PreparationResult(
+                    success=False,
+                    branch_name=target_branch,
+                    working_directory=cwd,
+                    default_branch=default_branch,
+                    is_worktree=False,
+                    error=f"Failed to cut {target_branch} from origin/{effective_base}",
+                )
+            logger.info(f"Created {target_branch} stacked on origin/{effective_base}")
         else:
+            # Default cut: sync to the default branch, then branch off it.
+            rc, _, _ = await _run_git("checkout", default_branch, cwd=cwd, check=False)
+            if rc != 0:
+                return PreparationResult(
+                    success=False,
+                    branch_name=target_branch,
+                    working_directory=cwd,
+                    default_branch=default_branch,
+                    is_worktree=False,
+                    error=f"Failed to checkout {default_branch}. Does the branch exist?",
+                )
+
+            rc, _, _ = await _run_git(
+                "merge", "--ff-only", f"origin/{default_branch}", cwd=cwd, check=False
+            )
+            if rc != 0:
+                logger.warning(
+                    f"Fast-forward merge failed for {default_branch}, resetting to origin"
+                )
+                await _run_git("reset", "--hard", f"origin/{default_branch}", cwd=cwd, check=False)
+                warnings.append(
+                    f"Fast-forward failed, reset {default_branch} to origin/{default_branch}"
+                )
+
             await _run_git("checkout", "-b", target_branch, cwd=cwd)
             logger.info(f"Created new branch: {target_branch}")
 
@@ -395,7 +448,7 @@ class WorkspacePreparation:
             )
 
         await persist_branch_provenance(
-            task_id=task_id, branch=target_branch, base_branch=default_branch
+            task_id=task_id, branch=target_branch, base_branch=effective_base
         )
 
         return PreparationResult(

{steerdev-1.1.28 → steerdev-1.1.31}/src/steerdev_agent/worktree.py

@@ -206,6 +206,16 @@ class WorktrunkClient:
         return None
 
 
+def wave_branch_name(name: str | None, wave_number: int) -> str:
+    """The single source of truth for a wave's git branch name.
+
+    A wave branch is its `name` (e.g. "wave-a1b2c3"), falling back to
+    "wave-{wave_number}". Used by `compute_branch_name` for the current wave and
+    by the runner to derive a predecessor wave's branch for stacked-wave cuts.
+    """
+    return name or f"wave-{wave_number}"
+
+
 def compute_branch_name(
     task: dict[str, Any],
     wave_context: WaveContext | None = None,
@@ -225,7 +235,7 @@ def compute_branch_name(
         Branch name string.
     """
     if wave_context:
-        return wave_context.wave_name or f"wave-{wave_context.wave_number}"
+        return wave_branch_name(wave_context.wave_name, wave_context.wave_number)
 
     # Try external ticket ID first (e.g., Linear "PROJ-123")
     external_id = task.get("linear_identifier") or task.get("external_id")

steerdev-1.1.31/tests/test_git_commit.py

@@ -0,0 +1,127 @@
+"""Tests for the git/commit module (per-task boundary commit)."""
+
+import asyncio
+import subprocess
+from pathlib import Path
+
+from steerdev_agent.git.commit import build_task_commit_message, commit_task_boundary
+
+# ── build_task_commit_message ───────────────────────────────────────────────
+
+
+def test_message_uses_linear_identifier():
+    task = {"id": "abc12345xyz", "linear_identifier": "PROJ-123", "title": "Add auth"}
+    assert build_task_commit_message(task) == "[PROJ-123] Add auth"
+
+
+def test_message_falls_back_to_external_id():
+    task = {"id": "abc12345xyz", "external_id": "JIRA-9", "title": "Add auth"}
+    assert build_task_commit_message(task) == "[JIRA-9] Add auth"
+
+
+def test_message_prefers_linear_over_external():
+    task = {
+        "id": "abc12345xyz",
+        "linear_identifier": "PROJ-123",
+        "external_id": "JIRA-9",
+        "title": "Add auth",
+    }
+    assert build_task_commit_message(task) == "[PROJ-123] Add auth"
+
+
+def test_message_falls_back_to_short_id():
+    task = {"id": "abc12345xyz9999", "title": "Add auth"}
+    assert build_task_commit_message(task) == "[task:abc12345] Add auth"
+
+
+def test_message_handles_missing_title():
+    task = {"id": "abc12345xyz", "linear_identifier": "PROJ-123"}
+    assert build_task_commit_message(task) == "[PROJ-123]"
+
+
+# ── commit_task_boundary ─────────────────────────────────────────────────────
+
+
+def _git(cwd: Path, *args: str) -> None:
+    subprocess.run(["git", *args], cwd=cwd, check=True, capture_output=True)
+
+
+def _make_repo(tmp_path: Path) -> Path:
+    work = tmp_path / "work"
+    work.mkdir()
+    _git(work, "init")
+    _git(work, "config", "user.email", "t@t.dev")
+    _git(work, "config", "user.name", "t")
+    (work / "f.txt").write_text("a")
+    _git(work, "add", "-A")
+    _git(work, "commit", "-m", "init")
+    return work
+
+
+def _head_message(work: Path) -> str:
+    out = subprocess.run(
+        ["git", "log", "-1", "--pretty=%s"],
+        cwd=work,
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return out.stdout.strip()
+
+
+def _commit_count(work: Path) -> int:
+    out = subprocess.run(
+        ["git", "rev-list", "--count", "HEAD"],
+        cwd=work,
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return int(out.stdout.strip())
+
+
+def test_commits_outstanding_changes(tmp_path):
+    work = _make_repo(tmp_path)
+    _git(work, "checkout", "-b", "wave-1")
+    (work / "f.txt").write_text("changed")
+    (work / "new.txt").write_text("new file")
+
+    task = {"id": "abc12345xyz", "linear_identifier": "PROJ-7", "title": "do work"}
+    result = asyncio.run(commit_task_boundary(work, task))
+
+    assert result == "committed"
+    assert _head_message(work) == "[PROJ-7] do work"
+    # Both the modified and the untracked file are committed (git add -A).
+    assert _commit_count(work) == 2
+
+
+def test_nothing_to_commit_when_clean(tmp_path):
+    work = _make_repo(tmp_path)
+    _git(work, "checkout", "-b", "wave-1")
+
+    task = {"id": "abc12345xyz", "title": "nothing"}
+    result = asyncio.run(commit_task_boundary(work, task))
+
+    assert result == "nothing_to_commit"
+    assert _commit_count(work) == 1
+
+
+def test_skips_protected_branch(tmp_path):
+    work = _make_repo(tmp_path)  # stays on default branch (main/master)
+    (work / "f.txt").write_text("changed on protected")
+
+    task = {"id": "abc12345xyz", "title": "do work"}
+    result = asyncio.run(commit_task_boundary(work, task))
+
+    assert result == "skipped_protected"
+    assert _commit_count(work) == 1  # nothing committed
+
+
+def test_never_raises_on_non_repo(tmp_path):
+    not_a_repo = tmp_path / "plain"
+    not_a_repo.mkdir()
+
+    task = {"id": "abc12345xyz", "title": "do work"}
+    # Must not raise; returns a status marker.
+    result = asyncio.run(commit_task_boundary(not_a_repo, task))
+    assert result == "failed"