forgeo-cli 0.7.1__tar.gz → 0.7.3__tar.gz

{forgeo_cli-0.7.1 → forgeo_cli-0.7.3}/.gitignore

@@ -29,6 +29,7 @@ dist/
 # AI assistant context
 AGENTS.md
 CONTEXT.md
+CLAUDE.md
 
 # Local deploy script (server-specific paths)
-scripts/deploy-docs.sh
+scripts/deploy-docs.sh

{forgeo_cli-0.7.1 → forgeo_cli-0.7.3}/CHANGELOG.md

@@ -7,6 +7,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.7.3] - 2026-08-19
+
+### Added
+
+- The agent's stdout/stderr is now persisted on the task as `agent_response`
+  when a task transitions (BLOCKED/FAILED/COMPLETED), shown in the web
+  console's task modal. A transition that carries no output never wipes a
+  previously stored response.
+- `agent_response_lines` config key: how many agent output lines the task's
+  `agent_response` keeps on a status transition. Unbounded by default; `0`
+  disables persisting agent output on the task.
+
+## [0.7.2] - 2026-08-18
+
+### Added
+
+- `no_changes_retry_max` config key: a task whose agent exits `0` without
+  producing any code changes is re-run immediately, in the same cycle, up to
+  that many extra times before it is marked `BLOCKED` for human review.
+
+### Changed
+
+- A silent no-change SUCCESS (agent exits `0` with an unchanged working tree)
+  now marks the task `BLOCKED` instead of `FAILED`: the only acceptable
+  outcome for a run that ends without code changes is a blocked task awaiting
+  human review. An agent that needs no code change must still opt in
+  explicitly with `no_changes_exit_code` to complete the task.
+
 ## [0.7.1] - 2026-08-17
 
 ### Added
@@ -321,7 +349,9 @@ Initial release of the scheduled, agent-driven software forgeo.
   overlapping-run skipping.
 - Dogfooding docs removed; local configs kept out of the repository.
 
-[Unreleased]: https://github.com/lucaGazzola/forgeo/compare/v0.7.1...HEAD
+[Unreleased]: https://github.com/lucaGazzola/forgeo/compare/v0.7.3...HEAD
+[0.7.3]: https://github.com/lucaGazzola/forgeo/compare/v0.7.2...v0.7.3
+[0.7.2]: https://github.com/lucaGazzola/forgeo/compare/v0.7.1...v0.7.2
 [0.7.1]: https://github.com/lucaGazzola/forgeo/compare/v0.7.0...v0.7.1
 [0.7.0]: https://github.com/lucaGazzola/forgeo/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/lucaGazzola/forgeo/compare/v0.5.0...v0.6.0

{forgeo_cli-0.7.1 → forgeo_cli-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: forgeo-cli
-Version: 0.7.1
+Version: 0.7.3
 Summary: A scheduled software forgeo: executes backlog tasks on main, refactors when idle, and writes BLOCKER.md when it needs human input.
 Project-URL: Homepage, https://forgeo.org
 Project-URL: Documentation, https://forgeo.org

{forgeo_cli-0.7.1 → forgeo_cli-0.7.3}/docs/agent-contract.md

@@ -69,8 +69,11 @@ Forgeo cannot tell "the agent deliberately made no changes" from "the agent
 did nothing". A `SUCCESS` exit that produces **no changes is therefore not a
 valid completion for a task**:
 
-- exiting `0` while leaving the working tree **unchanged** fails the task
-  (`FAILED`, reason: *"Agent exited 0 but produced no changes"*);
+- exiting `0` while leaving the working tree **unchanged** is retried
+  immediately (`no_changes_retry_max`, see [Configuration](configuration.md))
+  and, once that budget is spent, the task is marked `BLOCKED` — never
+  `FAILED` and never silently `COMPLETED`. The only acceptable outcome for a
+  run that ends without code changes is a blocked task awaiting human review;
 - to complete a task **without touching the code**, exit
   `no_changes_exit_code` (default `3`). The working tree must be clean — an
   agent that reports "no changes" while leaving uncommitted work behind fails
@@ -121,7 +124,7 @@ that, based on the exit code. The working contract is:
 - **do not** run `git add`, `git commit`, `git push`, or reset the tree;
 - exit `0` to have your changes committed and pushed as one commit;
 - exit `no_changes_exit_code` when the task needs no code change (never exit
-  `0` with an empty tree — that fails the task);
+  `0` with an empty tree — that run is retried and then marked `BLOCKED`);
 - exit `blocked_exit_code` to have partial work preserved and a blocker
   written;
 - exit anything else to have your changes discarded.

{forgeo_cli-0.7.1 → forgeo_cli-0.7.3}/docs/backlog.md

@@ -43,6 +43,7 @@ Each entry in `tasks` is a task object:
 | <span style="white-space: nowrap">`blocker_reason`</span> | list[string] | `[]` | Engine-managed: the agent's explanation (its questions, falling back to captured output) when the task becomes `BLOCKED`. Cleared on reopen; not editable via `PATCH`. |
 | <span style="white-space: nowrap">`blocked_count`</span> | integer | `0` | Engine-managed: how many times the task has transitioned into `BLOCKED`. Kept as history when the task is reopened, so you can see a task that keeps blocking needs splitting or rewriting rather than a blind retry. Not editable via `PATCH`. |
 | <span style="white-space: nowrap">`failure_reason`</span> | list[string] | `[]` | Engine-managed: the agent's error when the task becomes `FAILED` (e.g. a timeout message or a non-zero exit code). Shown in the web console's task modal so you can see why a task failed without opening the logs. Cleared when the task leaves the `FAILED` state; not editable via `PATCH`. |
+| <span style="white-space: nowrap">`agent_response`</span> | string / `null` | `null` | Engine-managed: the agent's last stdout/stderr, stripped of its stream prefixes and persisted on the task's status transitions (bounded by `agent_response_lines` when set). Shown in the web console's task modal; not editable via `PATCH`. |
 | <span style="white-space: nowrap">`retries_left`</span> | integer / `null` | `null` | Per-task override of the automatic-retry budget (`failed_retry_max` in the config): how many times this task may be retried after a failure. `null` falls back to the config; `0` disables retries for this task. Editable via `PATCH`. |
 | <span style="white-space: nowrap">`retry_count`</span> | integer | `0` | Engine-managed: how many times this task has already been retried. Shown in `runs.jsonl` and the web console; reset when a human reopens a `FAILED` task. Not editable via `PATCH`. |
 | <span style="white-space: nowrap">`failed_wait_cycles`</span> | integer | `0` | Engine-managed: how many cycles this task has been `FAILED` awaiting a retry (backed off by `failed_retry_wait_cycles`). Reset when the task leaves `FAILED`. Not editable via `PATCH`. |

{forgeo_cli-0.7.1 → forgeo_cli-0.7.3}/docs/configuration.md

@@ -40,8 +40,10 @@ paths), so `forgeo restart` is still used for those.
 | <span style="white-space: nowrap">`log_file`</span> | `forgeo.log` | Where the daemon writes its log. |
 | <span style="white-space: nowrap">`run_history_keep`</span> | `2000` | How many finished runs `runs.jsonl` keeps (oldest trimmed atomically on append). `0` disables retention (file grows forever). |
 | <span style="white-space: nowrap">`run_output_lines`</span> | `200` | How many agent output lines each run record keeps in `runs.jsonl` (the bounded tail of the agent's stdout/stderr). `0` disables persisting agent output. |
+| <span style="white-space: nowrap">`agent_response_lines`</span> | — (unbounded) | How many agent output lines the task's `agent_response` keeps on a status transition (the bounded tail of the agent's stdout/stderr, shown in the task modal / available to a backlog consumer). Omit = unbounded; `0` disables persisting agent output on the task. |
 | <span style="white-space: nowrap">`failed_retry_max`</span> | `0` | How many times a `FAILED` task is retried automatically. `0` (default) = a `FAILED` task stays `FAILED` until a human reopens it, exactly as before. A task may override this budget per-task with `retries_left`. |
 | <span style="white-space: nowrap">`failed_retry_wait_cycles`</span> | `1` | How many cycles a retry-eligible `FAILED` task waits (backoff) before it is moved back to `OPEN`. |
+| <span style="white-space: nowrap">`no_changes_retry_max`</span> | `0` | How many times a task whose agent exits `0` without producing any code changes is re-run immediately, in the same cycle, before the task is marked `BLOCKED` for human review. `0` (default) = a silent no-change SUCCESS is marked `BLOCKED` on the first attempt. |
 | <span style="white-space: nowrap">`git_timeout_seconds`</span> | `120` | Kill a git subprocess after this many seconds. |
 | <span style="white-space: nowrap">`telegram_bot_token`</span> | — | Telegram bot token for blocked-run notifications (disabled unless `telegram_chat_id` is also set). |
 | <span style="white-space: nowrap">`telegram_chat_id`</span> | — | Chat ID that receives blocked-run notifications (disabled unless `telegram_bot_token` is also set). |
@@ -225,6 +227,18 @@ Set `0` to stop persisting agent output entirely (run records stay small and
 the History tab shows nothing for them). Old run records written before this
 field existed simply have no output.
 
+### `agent_response_lines`
+
+Alongside the per-run record above, Forgeo persists the agent's output on the
+task itself (`agent_response`, shown in the task modal and available to a
+backlog consumer served over HTTP). Unlike `run_output_lines` it is **unbounded
+by default**: the whole stdout/stderr is stored, overwritten on each status
+transition (a transition that carries no output never wipes a previously
+stored response).
+
+Set a positive value to keep only the last that many lines; set `0` to stop
+persisting agent output on the task entirely.
+
 ### `failed_retry_max` / `failed_retry_wait_cycles`
 
 Some failures are transient — a network blip, a flaky test, a dependency
@@ -254,6 +268,28 @@ failed_retry_max: 3           # retry each FAILED task up to 3 times
 failed_retry_wait_cycles: 2   # back off 2 cycles before each retry
 ```
 
+### `no_changes_retry_max`
+
+An agent that exits `0` while leaving the working tree unchanged has not
+completed the task — the engine cannot tell "deliberately did nothing" from
+"did nothing". By default (`no_changes_retry_max: 0`) that run is marked
+`BLOCKED` on the first attempt: the only acceptable outcome for a no-change
+run is a blocked task awaiting human review, never a silent completion and
+never a `FAILED` task.
+
+Sometimes the agent needs a second chance (a flaky model, a transient context
+issue). Set a positive `no_changes_retry_max` and Forgeo re-runs the agent
+immediately, back-to-back in the **same cycle**, that many extra times; a run
+that finally produces changes completes the task, and one that still produces
+nothing after the budget is spent is marked `BLOCKED`.
+
+```yaml
+no_changes_retry_max: 2       # re-run the agent up to 2 extra times on a silent no-change
+```
+
+`BLOCKED` tasks are never auto-retried — a human decides whether to reopen,
+split, or drop the task (see [Backlog](backlog.md)).
+
 ### Telegram notifications
 
 Both `telegram_bot_token` **and** `telegram_chat_id` must be set for blocked

{forgeo_cli-0.7.1 → forgeo_cli-0.7.3}/docs/web-console-api.md

@@ -177,6 +177,7 @@ curl http://127.0.0.1:8790/api/instances/my-repo/tasks
     "blocker_reason": [],
     "blocked_count": 0,
     "failure_reason": [],
+    "agent_response": null,
     "created_at": "2026-07-31T10:00:00Z",
     "updated_at": "2026-07-31T10:00:00Z",
     "run_at": null,
@@ -258,6 +259,7 @@ curl -X POST http://127.0.0.1:8790/api/instances/my-repo/tasks \
   "blocker_reason": [],
   "blocked_count": 0,
   "failure_reason": [],
+  "agent_response": null,
   "created_at": "2026-08-01T12:00:00Z",
   "updated_at": "2026-08-01T12:00:00Z",
   "run_at": "2026-08-20T12:30:00Z",
@@ -300,6 +302,7 @@ curl -X POST http://127.0.0.1:8790/api/instances/my-repo/tasks/TASK-001/reopen
   "blocker_reason": [],
   "blocked_count": 1,
   "failure_reason": [],
+  "agent_response": null,
   "created_at": "2026-07-31T10:00:00Z",
   "updated_at": "2026-08-01T12:00:00Z",
   "dependencies": [],
@@ -329,8 +332,9 @@ budget override; a non-negative integer or `null`), and `run_at` (the
 optional one-shot schedule; an ISO-8601 datetime string or `null` to clear
 it). The request body is a JSON object; omitted fields are left unchanged
 and `id`, `status`, `blocker_reason`, `blocked_count`, `failure_reason`,
-`retry_count`, `failed_wait_cycles`, and `created_at` are always preserved
-(they are engine-managed — `PATCH` rejects them like it rejects `status`).
+`agent_response`, `retry_count`, `failed_wait_cycles`, and `created_at` are
+always preserved (they are engine-managed — `PATCH` rejects them like it
+rejects `status`).
 `agent_command` may be a string, an array, or `null` (clear the per-task
 override); `agent_timeout_seconds` may be a positive number or `null`.
 `updated_at` is bumped to the current time.
@@ -350,6 +354,7 @@ curl -X PATCH http://127.0.0.1:8790/api/instances/my-repo/tasks/TASK-001 \
   "blocker_reason": [],
   "blocked_count": 0,
   "failure_reason": [],
+  "agent_response": null,
   "created_at": "2026-07-31T10:00:00Z",
   "updated_at": "2026-08-01T12:00:00Z",
   "dependencies": [],
@@ -364,8 +369,8 @@ Errors:
 
 - `400` with `{"error": "..."}` — unparseable or non-object body, an empty
   body, an unknown field (e.g. `status`, `blocker_reason`, `blocked_count`,
-  `failure_reason`), or an invalid value (blank `title`, wrong field types, a
-  non-positive `agent_timeout_seconds`).
+  `failure_reason`, `agent_response`), or an invalid value (blank `title`,
+  wrong field types, a non-positive `agent_timeout_seconds`).
 - `404` with `{"error": "not found"}` — the task id does not exist in that
   instance's backlog.
 - `404` with `{"error": "unknown instance"}` — the instance is not

{forgeo_cli-0.7.1 → forgeo_cli-0.7.3}/install.sh

@@ -14,7 +14,7 @@ set -eu
 
 REPO_OWNER="lucaGazzola"
 REPO_NAME="forgeo"
-DEFAULT_VERSION="0.7.1"
+DEFAULT_VERSION="0.7.3"
 MIN_PYTHON="3.11"
 PYPI_PACKAGE="forgeo-cli"
 PREFIX="${FORGEO_PREFIX:-${HOME:-}/.local}"

{forgeo_cli-0.7.1 → forgeo_cli-0.7.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "forgeo-cli"
-version = "0.7.1"
+version = "0.7.3"
 description = "A scheduled software forgeo: executes backlog tasks on main, refactors when idle, and writes BLOCKER.md when it needs human input."
 readme = "README.md"
 requires-python = ">=3.11"

{forgeo_cli-0.7.1 → forgeo_cli-0.7.3}/src/forgeo/__init__.py

@@ -7,4 +7,4 @@ try:
 
     __version__ = _pkg_version("forgeo-cli")
 except PackageNotFoundError:  # standalone binary: no installed package metadata
-    __version__ = "0.7.1"
+    __version__ = "0.7.3"

{forgeo_cli-0.7.1 → forgeo_cli-0.7.3}/src/forgeo/backlog.py

@@ -36,7 +36,7 @@ from typing import Any
 from pydantic import ValidationError
 
 from forgeo.io import atomic_write_text
-from forgeo.models import ForgeoConfig, Task, TaskStatus
+from forgeo.models import ExecutionResult, ForgeoConfig, Task, TaskStatus
 
 logger = logging.getLogger(__name__)
 
@@ -59,6 +59,32 @@ EDITABLE_TASK_FIELDS = frozenset(
 )
 
 
+def _join_output_logs(result: ExecutionResult, cap: int | None = None) -> str | None:
+    """The agent's output as one newline-joined string, ``None`` when empty.
+
+    ``BacklogStore`` persists agent output as a single string field, so the
+    agent's ``list[str]`` (its ``[stdout]``/``[stderr]``-prefixed lines) is
+    flattened here, prefixes stripped. An empty result means "nothing to
+    record" and must stay ``None`` — the caller then leaves any previously
+    stored response untouched rather than wiping it. ``cap`` bounds the number
+    of kept lines, mirroring ``agent_response_lines`` (``None`` = unbounded;
+    ``0``/negative = persist nothing).
+    """
+
+    prefixes = ("[stdout]", "[stderr]")
+    out = [
+        line[len(prefix) + 1 :]
+        for line in result.output_logs
+        for prefix in prefixes
+        if line.startswith(prefix)
+    ]
+    if cap is not None:
+        if cap <= 0:
+            return None
+        out = out[-cap:]
+    return "\n".join(out) if out else None
+
+
 def unsatisfied_dependencies(tasks: list[Task], task: Task) -> list[dict[str, str]]:
     """The dependencies of ``task`` that are not yet satisfied.
 
@@ -208,8 +234,9 @@ class BacklogStore(ABC):
     concurrent mutations within one process — lives here.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, *, output_cap: int | None = None) -> None:
         self._lock = asyncio.Lock()
+        self._output_cap = output_cap
 
     @abstractmethod
     async def _read(self) -> dict[str, Any]:
@@ -253,7 +280,9 @@ class BacklogStore(ABC):
             await self._write(store)
         return task
 
-    async def update_status(self, task_id: str, status: TaskStatus) -> Task | None:
+    async def update_status(
+        self, task_id: str, status: TaskStatus, result: ExecutionResult
+    ) -> Task | None:
         """Transition a task's status, bumping its ``updated_at`` timestamp.
 
         Any transition away from ``FAILED`` clears the persisted
@@ -270,6 +299,9 @@ class BacklogStore(ABC):
                 and status is not TaskStatus.FAILED
             )
             entry["status"] = status.value
+            joined = _join_output_logs(result, self._output_cap)
+            if joined is not None:
+                entry["agent_response"] = joined
             if status is not TaskStatus.FAILED:
                 entry["failure_reason"] = []
                 if leaving_failed:
@@ -278,7 +310,9 @@ class BacklogStore(ABC):
 
         return await self._update_entry(task_id, mutate)
 
-    async def set_blocked(self, task_id: str, reason: list[str]) -> Task | None:
+    async def set_blocked(
+        self, task_id: str, reason: list[str], result: ExecutionResult
+    ) -> Task | None:
         """Mark a task ``BLOCKED``, persisting the agent's blocker reason.
 
         ``reason`` is stored on the task as ``blocker_reason`` (the source
@@ -291,10 +325,15 @@ class BacklogStore(ABC):
             entry["blocker_reason"] = list(reason)
             entry["blocked_count"] = int(entry.get("blocked_count", 0)) + 1
             entry["failure_reason"] = []
+            joined = _join_output_logs(result, self._output_cap)
+            if joined is not None:
+                entry["agent_response"] = joined
 
         return await self._update_entry(task_id, mutate)
 
-    async def set_failed(self, task_id: str, reason: list[str]) -> Task | None:
+    async def set_failed(
+        self, task_id: str, reason: list[str], result: ExecutionResult
+    ) -> Task | None:
         """Mark a task ``FAILED``, persisting the failure reason.
 
         ``reason`` is stored on the task as ``failure_reason`` (shown in the
@@ -307,6 +346,9 @@ class BacklogStore(ABC):
             entry["status"] = TaskStatus.FAILED.value
             entry["failure_reason"] = list(reason)
             entry["failed_wait_cycles"] = 0
+            joined = _join_output_logs(result, self._output_cap)
+            if joined is not None:
+                entry["agent_response"] = joined
 
         return await self._update_entry(task_id, mutate)
 
@@ -490,8 +532,9 @@ class JSONBacklog(BacklogStore):
         path: str | Path,
         *,
         snapshot_count: int = DEFAULT_SNAPSHOT_COUNT,
+        output_cap: int | None = None,
     ) -> None:
-        super().__init__()
+        super().__init__(output_cap=output_cap)
         self.path = Path(path)
         self.snapshot_count = max(0, snapshot_count)
 
@@ -622,5 +665,7 @@ def open_backlog(config: ForgeoConfig) -> BacklogStore:
         # it at module level would close an import cycle.
         from forgeo.backlog_http import HttpBacklog
 
-        return HttpBacklog(str(config.backlog), auth=config.backlog_auth)
-    return JSONBacklog(Path(config.backlog))
+        return HttpBacklog(
+            str(config.backlog), auth=config.backlog_auth, output_cap=config.agent_response_lines
+        )
+    return JSONBacklog(Path(config.backlog), output_cap=config.agent_response_lines)

{forgeo_cli-0.7.1 → forgeo_cli-0.7.3}/src/forgeo/backlog_http.py

@@ -55,8 +55,9 @@ class HttpBacklog(BacklogStore):
         *,
         auth: BacklogAuth | None = None,
         timeout_seconds: float = REQUEST_TIMEOUT_SECONDS,
+        output_cap: int | None = None,
     ) -> None:
-        super().__init__()
+        super().__init__(output_cap=output_cap)
         self.url = url
         self.timeout_seconds = timeout_seconds
         self._tokens = (
@@ -69,7 +70,7 @@ class HttpBacklog(BacklogStore):
     async def _read(self) -> dict[str, Any]:
         """GET the document; anything but a usable response raises."""
         body = await asyncio.to_thread(self._request, "GET", None)
-        logger.info("GET %s returned body: %s", self.url, body)
+        logger.debug("GET %s returned body: %s", self.url, body)
         try:
             data = json.loads(body) if body.strip() else {}
         except json.JSONDecodeError as exc:
@@ -81,6 +82,7 @@ class HttpBacklog(BacklogStore):
     async def _write(self, store: dict[str, Any]) -> None:
         """POST the whole document back."""
         payload = json.dumps(store, indent=2, ensure_ascii=False).encode("utf-8")
+        logger.debug("POST %s %s", self.url, payload)
         await asyncio.to_thread(self._request, "POST", payload)
 
     # ------------------------------------------------------------------ #

{forgeo_cli-0.7.1 → forgeo_cli-0.7.3}/src/forgeo/forgeo.py

@@ -359,31 +359,54 @@ class Forgeo:
     # ------------------------------------------------------------------ #
 
     async def _run_task(self, task: Task) -> None:
-        """Execute one task: agent run, then commit/push on the main branch."""
+        """Execute one task: agent run(s), then commit/push on the main branch.
+
+        A silent no-change SUCCESS (exit 0 with an empty tree) is re-run up to
+        ``no_changes_retry_max`` more times in the same cycle; once the retry
+        budget is spent the task is marked ``BLOCKED`` for human review — the
+        only acceptable outcome for a task that ends without code changes.
+        """
         logger.info("Running task %s (%s)", task.id, task.title)
-        result, ok = await self._run_agent(
-            task,
-            instruction=task.instruction,
-            success_message=task.title,
-            blocked_message=f"{task.title} [partial]",
-            command=task.agent_command,
-            timeout_seconds=task.agent_timeout_seconds,
-        )
+        max_retries = self.config.no_changes_retry_max
+        for attempt in range(max_retries + 1):
+            self._last_run_reason = None
+            result, ok = await self._run_agent(
+                task,
+                instruction=task.instruction,
+                success_message=task.title,
+                blocked_message=f"{task.title} [partial]",
+                command=task.agent_command,
+                timeout_seconds=task.agent_timeout_seconds,
+            )
 
-        if result.status is ExecutionStatus.BLOCKED:
-            await self.backlog.set_blocked(task.id, result.reason)
-            return
-        if result.status is ExecutionStatus.ERROR:
-            await self._mark_failed(task, self._failure_reason(result))
-            return
-        if not ok:
-            # SUCCESS whose commit (or no-change) path failed: already marked
-            # FAILED inside _handle_execution_result.
+            if result.status is ExecutionStatus.BLOCKED:
+                await self.backlog.set_blocked(task.id, result.reason, result)
+                return
+            if result.status is ExecutionStatus.ERROR:
+                await self._mark_failed(task, self._failure_reason(result), result)
+                return
+            if ok:
+                await self.backlog.update_status(task.id, TaskStatus.COMPLETED, result)
+                self.config.blocker_file.unlink(missing_ok=True)
+                self._notify_webhook("completed", task, "")
+                logger.info("Task %s completed.", task.id)
+                return
+            # Not ok: either the commit failed (the task is already marked
+            # FAILED inside _handle_execution_result) or the agent exited 0
+            # without producing changes (only the reason distinguishes them).
+            if self._last_run_reason != NO_CHANGES_REASON:
+                return
+            if attempt < max_retries:
+                logger.warning(
+                    "Task %s exited 0 but produced no changes "
+                    "(attempt %d/%d); retrying.",
+                    task.id,
+                    attempt + 1,
+                    max_retries,
+                )
+                continue
+            await self._block_no_changes(task)
             return
-        await self.backlog.update_status(task.id, TaskStatus.COMPLETED)
-        self.config.blocker_file.unlink(missing_ok=True)
-        self._notify_webhook("completed", task, "")
-        logger.info("Task %s completed.", task.id)
 
     async def _run_agent(
         self,
@@ -491,7 +514,10 @@ class Forgeo:
                 # Exited 0 but produced no changes: not a completion. The
                 # engine cannot tell "deliberately did nothing" from "did
                 # nothing", so the agent must opt into no-ops explicitly.
-                await self._fail_no_changes(task)
+                # The caller decides between an immediate re-run
+                # (``no_changes_retry_max``) and a BLOCKED outcome.
+                self._last_run_reason = NO_CHANGES_REASON
+                logger.warning("Task %s: %s.", task.id, NO_CHANGES_REASON)
                 return False
             return ok
 
@@ -533,34 +559,55 @@ class Forgeo:
     async def _fail(self, task: Task, result: ExecutionResult) -> None:
         """Discard the agent's work, mark the task FAILED, and log the error."""
         await self._discard_failed_work(task, result)
-        await self._mark_failed(task, self._failure_reason(result))
+        await self._mark_failed(task, self._failure_reason(result), result)
 
-    async def _mark_failed(self, task: Task, reason: list[str]) -> None:
+    async def _mark_failed(self, task: Task, reason: list[str], result: ExecutionResult) -> None:
         """Persist ``reason`` on ``task`` and send the ``failed`` webhook notice.
 
         Shared by the direct ERROR path (the work was already discarded in
         :meth:`_handle_execution_result`) and the FAILED transitions from
         :meth:`_fail` and :meth:`_complete_without_changes`.
         """
-        await self.backlog.set_failed(task.id, reason)
+        await self.backlog.set_failed(task.id, reason, result)
         self._notify_webhook("failed", task, "\n".join(reason))
 
-    async def _fail_no_changes(self, task: Task) -> None:
-        """Fail a task whose agent exited 0 without producing any changes.
+    async def _block_no_changes(self, task: Task) -> None:
+        """Mark a task whose agent exited 0 without producing any changes as
+        BLOCKED: the only acceptable outcome for a no-change run is a blocked
+        task awaiting human review.
 
         A no-change SUCCESS is indistinguishable from an agent that simply did
-        nothing, so it is not a valid completion: the task is marked FAILED
-        and the run record surfaces the reason instead of a silent null
-        commit.
+        nothing, so it is not a valid completion. After the retry budget is
+        spent the task is blocked (never FAILED), so the run record surfaces
+        the reason and the human decides whether to reopen, split, or drop the
+        task.
         """
         self._last_run_reason = NO_CHANGES_REASON
         logger.warning(
-            "Task %s exited 0 but produced no changes; marking FAILED.", task.id
+            "Task %s: %s; marking BLOCKED.", task.id, NO_CHANGES_REASON
         )
-        await self._fail(
-            task,
-            ExecutionResult(status=ExecutionStatus.ERROR, error=NO_CHANGES_REASON),
+        blocked = ExecutionResult(
+            status=ExecutionStatus.BLOCKED,
+            output_logs=(
+                self._last_agent_result.output_logs
+                if self._last_agent_result is not None
+                else []
+            ),
+            questions=[NO_CHANGES_REASON],
+            exit_code=(
+                self._last_agent_result.exit_code
+                if self._last_agent_result is not None
+                else None
+            ),
         )
+        self._last_agent_result = blocked
+        await self.backlog.set_blocked(task.id, [NO_CHANGES_REASON], blocked)
+        entry = BlockerEntry(
+            task=task,
+            result=blocked,
+            instruction=task.instruction,
+        )
+        self._notify_blocked(entry)
 
     async def _complete_without_changes(
         self, task: Task, *, is_refactor: bool = False
@@ -584,7 +631,11 @@ class Forgeo:
                 is_refactor=is_refactor,
             )
             if not is_refactor:
-                await self._mark_failed(task, [NO_CHANGES_DIRTY_REASON])
+                await self._mark_failed(
+                    task,
+                    [NO_CHANGES_DIRTY_REASON],
+                    self._last_agent_result or ExecutionResult(status=ExecutionStatus.ERROR),
+                )
             return False
         self._last_run_reason = NO_CHANGES_REPORTED_REASON
         logger.info(

{forgeo_cli-0.7.1 → forgeo_cli-0.7.3}/src/forgeo/models.py

@@ -165,8 +165,10 @@ class Task(BaseModel):
     ``blocker_reason`` and ``blocked_count`` are engine-managed: they record
     the last agent explanation when the task becomes ``BLOCKED`` and how many
     times that happened, respectively. ``failure_reason`` is likewise
-    engine-managed: the agent's error when the task becomes ``FAILED``. None
-    of them are editable through the web console's ``PATCH`` endpoint.
+    engine-managed: the agent's error when the task becomes ``FAILED``.
+    ``agent_response`` is likewise engine-managed: the last agent
+    stdout/stderr output persisted on a status transition. None of them are
+    editable through the web console's ``PATCH`` endpoint.
     ``retries_left`` is a human-set per-task override of the retry budget
     (``failed_retry_max`` in the config); ``retry_count`` and
     ``failed_wait_cycles`` are engine-managed retry state.
@@ -194,6 +196,14 @@ class Task(BaseModel):
     blocker_reason: list[str] = Field(default_factory=list)
     blocked_count: int = Field(default=0, ge=0)
     failure_reason: list[str] = Field(default_factory=list)
+    agent_response: str | None = Field(
+        default=None,
+        description="Engine-managed: the agent's last stdout/stderr output, "
+        "stripped of its stream prefixes and persisted on status transitions "
+        "(capped at ``agent_response_lines`` lines when set). ``None`` when "
+        "the transition carried no output. Intended for the backlog consumer; "
+        "not editable via ``PATCH``.",
+    )
     retries_left: int | None = Field(
         default=None,
         ge=0,
@@ -409,12 +419,21 @@ class ForgeoConfig(BaseModel):
         run_output_lines: How many agent output lines each run record keeps
             in ``runs.jsonl`` (the bounded tail of the agent's stdout/stderr).
             ``0`` disables persisting agent output entirely.
+        agent_response_lines: How many agent output lines the task's
+            ``agent_response`` keeps when it transitions (the bounded tail of
+            the agent's stdout/stderr). ``None`` (default) = unbounded;
+            ``0`` disables persisting agent output on the task.
         failed_retry_max: How many times a ``FAILED`` task is retried
             automatically (``0`` = disabled: a task stays ``FAILED`` until a
             human reopens it, exactly as before). A task may override this
             budget per-task with ``retries_left``.
         failed_retry_wait_cycles: How many cycles a retry-eligible ``FAILED``
             task waits (backoff) before it is moved back to ``OPEN``.
+        no_changes_retry_max: How many times a task whose agent exits ``0``
+            without producing any code changes is re-run immediately, in the
+            same cycle, before the task is marked ``BLOCKED`` for human
+            review. ``0`` (default) = a silent no-change SUCCESS is marked
+            ``BLOCKED`` on the first attempt.
         telegram_bot_token: Telegram bot token for blocked-run
             notifications. Disabled unless ``telegram_chat_id`` is also set.
         telegram_chat_id: Chat ID that receives blocked-run notifications.
@@ -451,8 +470,17 @@ class ForgeoConfig(BaseModel):
     log_file: str = "forgeo.log"
     run_history_keep: int = Field(default=DEFAULT_RUN_HISTORY_KEEP, ge=0)
     run_output_lines: int = Field(default=DEFAULT_RUN_OUTPUT_LINES, ge=0)
+    agent_response_lines: int | None = Field(
+        default=None,
+        ge=0,
+        description="How many agent output lines the task's ``agent_response`` "
+        "keeps on a status transition (the bounded tail of the agent's "
+        "stdout/stderr). ``None`` (default) = unbounded; ``0`` disables "
+        "persisting agent output on the task.",
+    )
     failed_retry_max: int = Field(default=0, ge=0)
     failed_retry_wait_cycles: int = Field(default=1, ge=1)
+    no_changes_retry_max: int = Field(default=0, ge=0)
     telegram_bot_token: str | None = None
     telegram_chat_id: str | None = None
     notify_webhook_url: str | None = None