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

{forgeo_cli-0.7.2 → 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.2 → forgeo_cli-0.7.3}/CHANGELOG.md

@@ -7,6 +7,18 @@ 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
@@ -337,7 +349,8 @@ 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.2...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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: forgeo-cli
-Version: 0.7.2
+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.2 → 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.2 → forgeo_cli-0.7.3}/docs/configuration.md

@@ -40,6 +40,7 @@ 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. |
@@ -226,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

{forgeo_cli-0.7.2 → 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.2 → forgeo_cli-0.7.3}/install.sh

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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "forgeo-cli"
-version = "0.7.2"
+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.2 → 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.2"
+    __version__ = "0.7.3"

{forgeo_cli-0.7.2 → 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.2 → 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.2 → forgeo_cli-0.7.3}/src/forgeo/forgeo.py

@@ -380,13 +380,13 @@ class Forgeo:
             )
 
             if result.status is ExecutionStatus.BLOCKED:
-                await self.backlog.set_blocked(task.id, result.reason)
+                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))
+                await self._mark_failed(task, self._failure_reason(result), result)
                 return
             if ok:
-                await self.backlog.update_status(task.id, TaskStatus.COMPLETED)
+                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)
@@ -559,16 +559,16 @@ 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 _block_no_changes(self, task: Task) -> None:
@@ -601,7 +601,7 @@ class Forgeo:
             ),
         )
         self._last_agent_result = blocked
-        await self.backlog.set_blocked(task.id, [NO_CHANGES_REASON])
+        await self.backlog.set_blocked(task.id, [NO_CHANGES_REASON], blocked)
         entry = BlockerEntry(
             task=task,
             result=blocked,
@@ -631,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.2 → 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,6 +419,10 @@ 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
@@ -456,6 +470,14 @@ 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)

{forgeo_cli-0.7.2 → forgeo_cli-0.7.3}/src/forgeo/web/central/central.js

@@ -626,6 +626,10 @@
     }
 
     setText("task-modal-description", task.description || "");
+    var agentResponse = document.getElementById("task-modal-agent-response");
+    if (agentResponse) {
+      agentResponse.textContent = task.agent_response || "";
+    }
     var acceptance = document.getElementById("task-modal-acceptance");
     if (acceptance) {
       acceptance.textContent = "";
@@ -696,6 +700,7 @@
       task.files_to_modify && task.files_to_modify.length > 0
     );
     showModalSection("task-modal-command-section", Boolean(task.agent_command));
+    showModalSection("task-modal-agent-response-section", Boolean(task.agent_response));
     showModalSection(
       "task-modal-retries-section",
       Boolean(retries && retries.textContent)
@@ -1211,6 +1216,7 @@
     { key: "blocker_file", label: "Blocker file", type: "text", hint: "Where BLOCKER.md is written when the agent needs human input. Keep it outside the repository." },
     { key: "log_file", label: "Log file", type: "text" },
     { key: "run_output_lines", label: "Run output lines", type: "number", min: 0, step: 1, hint: "How many agent output lines each run record keeps in runs.jsonl (bounded tail, shown in the History tab). 0 = don't persist agent output." },
+    { key: "agent_response_lines", label: "Agent response lines", type: "number", min: 0, step: 1, optional: true, hint: "How many agent output lines the task's agent_response keeps on a status transition (shown in the task modal). Empty = unbounded. 0 = don't persist agent output on the task." },
     { key: "failed_retry_max", label: "Failed retry max", type: "number", min: 0, step: 1, hint: "How many times a FAILED task is retried automatically. 0 = disabled (a FAILED task stays FAILED until a human reopens it). A task can override this with its own retries_left." },
     { key: "failed_retry_wait_cycles", label: "Failed retry wait (cycles)", type: "number", min: 1, step: 1, hint: "How many cycles a FAILED task waits (backoff) before it is retried." },
     { key: "no_changes_retry_max", label: "No-change retry max", type: "number", min: 0, step: 1, hint: "How many times a task whose agent exits 0 without producing any code changes is re-run immediately, in the same cycle, before it is marked BLOCKED for human review. 0 = block on the first attempt." },

{forgeo_cli-0.7.2 → forgeo_cli-0.7.3}/src/forgeo/web/central/instance.html

@@ -187,6 +187,16 @@
             full output.
           </p>
         </section>
+        <section class="modal__section" id="task-modal-agent-response-section" hidden>
+          <h3>Agent output</h3>
+          <pre class="modal__command" id="task-modal-agent-response"></pre>
+          <p class="modal__blocked-note">
+            The agent's last stdout/stderr for this task, persisted on its most
+            recent status transition (bounded by the configured
+            <code>agent_response_lines</code>). The full per-run output is in the
+            History tab.
+          </p>
+        </section>
         <div>
           <span class="badge" id="task-modal-status"></span>
         </div>

{forgeo_cli-0.7.2 → forgeo_cli-0.7.3}/tests/conftest.py

@@ -207,6 +207,19 @@ def make_task(**overrides) -> Task:
     return Task(**defaults)
 
 
+def make_result(**overrides) -> ExecutionResult:
+    """An agent result carrying no output, for transitions under test directly.
+
+    The backlog mutators require the result that drove the transition, but a
+    test exercising only the status bookkeeping has no agent run behind it.
+    This is that "nothing was captured" result: the transition records no
+    ``agent_response`` and leaves any previously stored one untouched.
+    """
+    defaults = {"status": ExecutionStatus.SUCCESS}
+    defaults.update(overrides)
+    return ExecutionResult(**defaults)
+
+
 def make_forgeo(
     git_repo: Path, tmp_path: Path, **overrides
 ) -> tuple[Forgeo, FakeAgent, JSONBacklog]:

{forgeo_cli-0.7.2 → forgeo_cli-0.7.3}/tests/test_backlog.py

@@ -12,10 +12,11 @@ from forgeo.backlog import (
     JSONBacklog,
     next_due_run_at,
     oldest_open_task,
+    open_backlog,
     unsatisfied_dependencies,
 )
 from forgeo.models import Task, TaskStatus
-from tests.conftest import make_task
+from tests.conftest import make_config, make_result, make_task
 
 
 def test_oldest_open_task_picks_oldest():
@@ -292,7 +293,7 @@ async def test_fetch_prefers_open_over_blocked(tmp_path):
 async def test_update_status_persists_and_bumps_timestamp(tmp_path):
     backlog = JSONBacklog(tmp_path / "backlog.json")
     task = await backlog.create_task(make_task())
-    updated = await backlog.update_status(task.id, TaskStatus.COMPLETED)
+    updated = await backlog.update_status(task.id, TaskStatus.COMPLETED, make_result())
     assert updated.status is TaskStatus.COMPLETED
     stored = await backlog.get_task(task.id)
     assert stored.status is TaskStatus.COMPLETED
@@ -302,18 +303,18 @@ async def test_update_status_persists_and_bumps_timestamp(tmp_path):
 async def test_update_status_unknown_id_returns_none(tmp_path):
     backlog = JSONBacklog(tmp_path / "backlog.json")
     await backlog.create_task(make_task())
-    assert await backlog.update_status("MISSING", TaskStatus.COMPLETED) is None
+    assert await backlog.update_status("MISSING", TaskStatus.COMPLETED, make_result()) is None
 
 
 async def test_set_blocked_persists_reason_and_increments_count(tmp_path):
     backlog = JSONBacklog(tmp_path / "backlog.json")
     task = await backlog.create_task(make_task())
-    blocked = await backlog.set_blocked(task.id, ["I need a decision"])
+    blocked = await backlog.set_blocked(task.id, ["I need a decision"], make_result())
     assert blocked.status is TaskStatus.BLOCKED
     assert blocked.blocker_reason == ["I need a decision"]
     assert blocked.blocked_count == 1
 
-    blocked = await backlog.set_blocked(task.id, ["Another decision"])
+    blocked = await backlog.set_blocked(task.id, ["Another decision"], make_result())
     assert blocked.blocked_count == 2
     assert blocked.blocker_reason == ["Another decision"]
 
@@ -332,17 +333,17 @@ async def test_set_blocked_persists_reason_and_increments_count(tmp_path):
 async def test_set_blocked_unknown_id_returns_none(tmp_path):
     backlog = JSONBacklog(tmp_path / "backlog.json")
     await backlog.create_task(make_task())
-    assert await backlog.set_blocked("MISSING", ["?"]) is None
+    assert await backlog.set_blocked("MISSING", ["?"], make_result()) is None
 
 
 async def test_set_failed_persists_reason(tmp_path):
     backlog = JSONBacklog(tmp_path / "backlog.json")
     task = await backlog.create_task(make_task())
-    failed = await backlog.set_failed(task.id, ["timed out after 60s"])
+    failed = await backlog.set_failed(task.id, ["timed out after 60s"], make_result())
     assert failed.status is TaskStatus.FAILED
     assert failed.failure_reason == ["timed out after 60s"]
 
-    failed = await backlog.set_failed(task.id, ["exit code 3"])
+    failed = await backlog.set_failed(task.id, ["exit code 3"], make_result())
     assert failed.status is TaskStatus.FAILED
     assert failed.failure_reason == ["exit code 3"]
 
@@ -359,14 +360,106 @@ async def test_set_failed_persists_reason(tmp_path):
 async def test_set_failed_unknown_id_returns_none(tmp_path):
     backlog = JSONBacklog(tmp_path / "backlog.json")
     await backlog.create_task(make_task())
-    assert await backlog.set_failed("MISSING", ["?"]) is None
+    assert await backlog.set_failed("MISSING", ["?"], make_result()) is None
+
+
+async def test_agent_response_persists_output_on_transitions(tmp_path):
+    """Status transitions persist the agent output, stream prefixes stripped."""
+    backlog = JSONBacklog(tmp_path / "backlog.json")
+    task = await backlog.create_task(make_task())
+    result = make_result(
+        output_logs=["[stdout] first line", "[stderr] warning", "untagged line"]
+    )
+
+    failed = await backlog.set_failed(task.id, ["boom"], result)
+    assert failed.agent_response == "first line\nwarning"
+    assert (await backlog.get_task(task.id)).agent_response == "first line\nwarning"
+
+    blocked = await backlog.set_blocked(task.id, ["blocked"], result)
+    assert blocked.agent_response == "first line\nwarning"
+
+    completed = await backlog.update_status(task.id, TaskStatus.COMPLETED, result)
+    assert completed.agent_response == "first line\nwarning"
+
+
+async def test_agent_response_none_without_output(tmp_path):
+    """A transition carrying no output records no agent_response."""
+    backlog = JSONBacklog(tmp_path / "backlog.json")
+    task = await backlog.create_task(make_task())
+
+    failed = await backlog.set_failed(task.id, ["boom"], make_result())
+    assert failed.agent_response is None
+    assert (await backlog.get_task(task.id)).agent_response is None
+
+
+async def test_agent_response_preserves_previous_when_nothing_to_record(tmp_path):
+    """A transition with no output never wipes a previously stored response."""
+    backlog = JSONBacklog(tmp_path / "backlog.json")
+    task = await backlog.create_task(make_task())
+    await backlog.set_failed(
+        task.id, ["boom"], make_result(output_logs=["[stderr] original failure"])
+    )
+    assert (await backlog.get_task(task.id)).agent_response == "original failure"
+
+    await backlog.update_status(task.id, TaskStatus.OPEN, make_result())
+    stored = await backlog.get_task(task.id)
+    assert stored.status is TaskStatus.OPEN
+    assert stored.agent_response == "original failure"
+
+
+async def test_agent_response_capped(tmp_path):
+    """agent_response keeps at most ``output_cap`` lines, the latest ones."""
+    backlog = JSONBacklog(tmp_path / "backlog.json", output_cap=2)
+    task = await backlog.create_task(make_task())
+    result = make_result(
+        output_logs=[f"[stdout] line {index}" for index in range(4)]
+    )
+
+    failed = await backlog.set_failed(task.id, ["boom"], result)
+    assert failed.agent_response == "line 2\nline 3"
+
+
+async def test_agent_response_disabled_with_zero_cap(tmp_path):
+    """output_cap=0 mirrors agent_response_lines=0: nothing is persisted."""
+    backlog = JSONBacklog(tmp_path / "backlog.json", output_cap=0)
+    task = await backlog.create_task(make_task())
+    result = make_result(output_logs=["[stdout] line"])
+
+    failed = await backlog.set_failed(task.id, ["boom"], result)
+    assert failed.agent_response is None
+
+
+async def test_agent_response_unbounded_by_default(tmp_path):
+    """Without agent_response_lines every output line is persisted."""
+    config = make_config(tmp_path, tmp_path)
+    assert config.agent_response_lines is None
+    backlog = open_backlog(config)
+    task = await backlog.create_task(make_task())
+    result = make_result(
+        output_logs=[f"[stdout] line {index}" for index in range(500)]
+    )
+
+    failed = await backlog.set_failed(task.id, ["boom"], result)
+    assert failed.agent_response == "\n".join(f"line {index}" for index in range(500))
+
+
+async def test_open_backlog_applies_agent_response_lines_cap(tmp_path):
+    """open_backlog wires the config's agent_response_lines into the store."""
+    config = make_config(tmp_path, tmp_path)
+    config.agent_response_lines = 1
+    backlog = open_backlog(config)
+    task = await backlog.create_task(make_task())
+    result = make_result(output_logs=["[stdout] first", "[stdout] second"])
+
+    failed = await backlog.set_failed(task.id, ["boom"], result)
+    assert failed.agent_response == "second"
 
 
 async def test_update_status_clears_failure_reason(tmp_path):
     backlog = JSONBacklog(tmp_path / "backlog.json")
     task = await backlog.create_task(make_task())
-    await backlog.set_failed(task.id, ["timed out after 60s"])
-    updated = await backlog.update_status(task.id, TaskStatus.OPEN)
+    await backlog.set_failed(task.id, ["timed out after 60s"], make_result())
+    updated = await backlog.update_status(task.id, TaskStatus.OPEN, make_result())
     assert updated.status is TaskStatus.OPEN
     assert updated.failure_reason == []
     stored = await backlog.get_task(task.id)
@@ -376,8 +469,8 @@ async def test_update_status_clears_failure_reason(tmp_path):
 async def test_set_blocked_clears_failure_reason(tmp_path):
     backlog = JSONBacklog(tmp_path / "backlog.json")
     task = await backlog.create_task(make_task())
-    await backlog.set_failed(task.id, ["timed out after 60s"])
-    blocked = await backlog.set_blocked(task.id, ["I need a decision"])
+    await backlog.set_failed(task.id, ["timed out after 60s"], make_result())
+    blocked = await backlog.set_blocked(task.id, ["I need a decision"], make_result())
     assert blocked.status is TaskStatus.BLOCKED
     assert blocked.failure_reason == []
     assert blocked.blocker_reason == ["I need a decision"]
@@ -386,7 +479,7 @@ async def test_set_blocked_clears_failure_reason(tmp_path):
 async def test_reopen_task_clears_failure_reason(tmp_path):
     backlog = JSONBacklog(tmp_path / "backlog.json")
     task = await backlog.create_task(make_task())
-    await backlog.set_failed(task.id, ["timed out after 60s"])
+    await backlog.set_failed(task.id, ["timed out after 60s"], make_result())
     reopened = await backlog.reopen_task(task.id)
     assert reopened.status is TaskStatus.OPEN
     assert reopened.failure_reason == []
@@ -395,7 +488,7 @@ async def test_reopen_task_clears_failure_reason(tmp_path):
 async def test_reopen_task_clears_reason_keeps_count(tmp_path):
     backlog = JSONBacklog(tmp_path / "backlog.json")
     task = await backlog.create_task(make_task())
-    await backlog.set_blocked(task.id, ["I need a decision"])
+    await backlog.set_blocked(task.id, ["I need a decision"], make_result())
     reopened = await backlog.reopen_task(task.id)
     assert reopened.status is TaskStatus.OPEN
     assert reopened.blocker_reason == []
@@ -708,11 +801,11 @@ async def test_set_failed_resets_failed_wait_cycles(tmp_path):
     """A fresh FAILED transition restarts the retry backoff."""
     backlog = JSONBacklog(tmp_path / "backlog.json")
     task = await backlog.create_task(make_task())
-    await backlog.set_failed(task.id, ["boom"])
+    await backlog.set_failed(task.id, ["boom"], make_result())
     await backlog.bump_failed_wait(task.id)
     assert (await backlog.get_task(task.id)).failed_wait_cycles == 1
 
-    refailed = await backlog.set_failed(task.id, ["boom again"])
+    refailed = await backlog.set_failed(task.id, ["boom again"], make_result())
     assert refailed.failed_wait_cycles == 0
     assert refailed.failure_reason == ["boom again"]
     stored = await backlog.get_task(task.id)
@@ -723,7 +816,7 @@ async def test_set_failed_resets_failed_wait_cycles(tmp_path):
 async def test_bump_failed_wait_increments(tmp_path):
     backlog = JSONBacklog(tmp_path / "backlog.json")
     task = await backlog.create_task(make_task())
-    await backlog.set_failed(task.id, ["boom"])
+    await backlog.set_failed(task.id, ["boom"], make_result())
     bumped = await backlog.bump_failed_wait(task.id)
     assert bumped.status is TaskStatus.FAILED
     assert bumped.failed_wait_cycles == 1
@@ -735,7 +828,7 @@ async def test_bump_failed_wait_increments(tmp_path):
 async def test_retry_task_reopens_and_increments_retry_count(tmp_path):
     backlog = JSONBacklog(tmp_path / "backlog.json")
     task = await backlog.create_task(make_task())
-    await backlog.set_failed(task.id, ["boom"])
+    await backlog.set_failed(task.id, ["boom"], make_result())
     retried = await backlog.retry_task(task.id)
     assert retried.status is TaskStatus.OPEN
     assert retried.retry_count == 1
@@ -764,15 +857,15 @@ async def test_update_status_leaving_failed_resets_retry_state(tmp_path):
     the human's retry gets a fresh failed_retry_max."""
     backlog = JSONBacklog(tmp_path / "backlog.json")
     task = await backlog.create_task(make_task())
-    await backlog.set_failed(task.id, ["boom"])
+    await backlog.set_failed(task.id, ["boom"], make_result())
     await backlog.retry_task(task.id)
-    await backlog.set_failed(task.id, ["boom again"])
+    await backlog.set_failed(task.id, ["boom again"], make_result())
     await backlog.bump_failed_wait(task.id)
     stored = await backlog.get_task(task.id)
     assert stored.retry_count == 1
     assert stored.failed_wait_cycles == 1
 
-    reopened = await backlog.update_status(task.id, TaskStatus.OPEN)
+    reopened = await backlog.update_status(task.id, TaskStatus.OPEN, make_result())
     assert reopened.status is TaskStatus.OPEN
     assert reopened.retry_count == 0
     assert reopened.failed_wait_cycles == 0

{forgeo_cli-0.7.2 → forgeo_cli-0.7.3}/tests/test_backlog_http.py

@@ -16,7 +16,7 @@ import pytest
 from forgeo.backlog import open_backlog
 from forgeo.backlog_http import BacklogUnavailableError, HttpBacklog
 from forgeo.models import BacklogAuth, ForgeoConfig, TaskStatus
-from tests.conftest import make_task
+from tests.conftest import make_result, make_task
 
 URL = "https://api.example.com/api/forgeo/backlog"
 SECRET_ENV = "FORGEO_TEST_CLIENT_SECRET"
@@ -104,7 +104,7 @@ async def test_status_transitions_round_trip_through_the_endpoint(
     backlog = HttpBacklog(URL)
     await backlog.create_task(make_task(id="TASK-001"))
 
-    await backlog.set_blocked("TASK-001", ["needs a decision"])
+    await backlog.set_blocked("TASK-001", ["needs a decision"], make_result())
     stored = endpoint.document["tasks"][0]
     assert stored["status"] == "BLOCKED"
     assert stored["blocker_reason"] == ["needs a decision"]

{forgeo_cli-0.7.2 → forgeo_cli-0.7.3}/tests/test_factory.py

@@ -20,7 +20,7 @@ from forgeo.models import (
     ExecutionStatus,
     TaskStatus,
 )
-from tests.conftest import git, make_forgeo, make_task
+from tests.conftest import git, make_forgeo, make_result, make_task
 
 
 class FakeResponse:
@@ -1126,7 +1126,7 @@ async def test_manual_reopen_of_failed_task_resets_retry_budget(git_repo, tmp_pa
     assert task.status is TaskStatus.FAILED
     assert task.retry_count == 1
 
-    await backlog.update_status("TASK-001", TaskStatus.OPEN)  # manual reopen
+    await backlog.update_status("TASK-001", TaskStatus.OPEN, make_result())  # manual reopen
     task = await backlog.get_task("TASK-001")
     assert task.status is TaskStatus.OPEN
     assert task.retry_count == 0

{forgeo_cli-0.7.2 → forgeo_cli-0.7.3}/tests/test_runs.py

@@ -20,7 +20,7 @@ from forgeo.models import (
 )
 from forgeo.paths import runs_path
 from forgeo.runs import RunRecorder
-from tests.conftest import git, make_forgeo, make_task
+from tests.conftest import git, make_forgeo, make_result, make_task
 
 
 def read_lines(path) -> list[dict]:
@@ -221,12 +221,12 @@ async def test_every_cycle_appends_exactly_one_line(git_repo, tmp_path):
     assert await forgeo.run_cycle() == "task"
     assert len(read_lines(runs)) == 1
 
-    await backlog.update_status("TASK-001", TaskStatus.OPEN)
+    await backlog.update_status("TASK-001", TaskStatus.OPEN, make_result())
     agent.result = ExecutionResult(status=ExecutionStatus.ERROR, error="boom", exit_code=3)
     assert await forgeo.run_cycle() == "task"
     assert len(read_lines(runs)) == 2
 
-    await backlog.update_status("TASK-001", TaskStatus.OPEN)
+    await backlog.update_status("TASK-001", TaskStatus.OPEN, make_result())
     agent.result = ExecutionResult(status=ExecutionStatus.BLOCKED, questions=["?"], exit_code=2)
     assert await forgeo.run_cycle() == "task"
     assert len(read_lines(runs)) == 3
@@ -234,18 +234,18 @@ async def test_every_cycle_appends_exactly_one_line(git_repo, tmp_path):
     assert await forgeo.run_cycle() == "blocked"
     assert len(read_lines(runs)) == 4
 
-    await backlog.update_status("TASK-001", TaskStatus.COMPLETED)
+    await backlog.update_status("TASK-001", TaskStatus.COMPLETED, make_result())
     forgeo.config.blocker_file.write_text("stale", encoding="utf-8")
     assert await forgeo.run_cycle() == "paused"
     assert len(read_lines(runs)) == 5
 
     forgeo.config.blocker_file.unlink()
-    await backlog.update_status("TASK-001", TaskStatus.OPEN)
+    await backlog.update_status("TASK-001", TaskStatus.OPEN, make_result())
     (git_repo / "manual.txt").write_text("wip\n", encoding="utf-8")
     assert await forgeo.run_cycle() == "dirty"
     assert len(read_lines(runs)) == 6
 
-    await backlog.update_status("TASK-001", TaskStatus.COMPLETED)
+    await backlog.update_status("TASK-001", TaskStatus.COMPLETED, make_result())
     git(git_repo, "clean", "-fd")
     agent.result = ExecutionResult(status=ExecutionStatus.SUCCESS, exit_code=0)
     assert await forgeo.run_cycle() == "refactor"
@@ -473,7 +473,7 @@ async def test_cycle_applies_configured_retention(git_repo, tmp_path):
     for _ in range(4):
         agent.result = ExecutionResult(status=ExecutionStatus.SUCCESS, exit_code=0)
         assert await forgeo.run_cycle() == "task"
-        await backlog.update_status("TASK-001", TaskStatus.OPEN)
+        await backlog.update_status("TASK-001", TaskStatus.OPEN, make_result())
 
     lines = read_lines(runs)
     assert len(lines) == 2

{forgeo_cli-0.7.2 → forgeo_cli-0.7.3}/tests/test_web.py

@@ -463,6 +463,7 @@ def test_instance_page_has_task_edit_modal(web_env):
     assert 'id="task-modal-reopen"' in body
     assert 'id="task-modal-blocker-section"' in body
     assert 'id="task-modal-failure-section"' in body
+    assert 'id="task-modal-agent-response-section"' in body
     assert 'id="task-modal-delete"' in body
     assert 'id="task-modal-edit-form"' in body
     assert 'id="task-modal-save"' in body
@@ -1138,6 +1139,33 @@ def test_task_json_exposes_failure_reason(web_env, registry):
     assert tasks[0]["failure_reason"] == ["timed out after 60s"]
 
 
+def agent_response_task_json(task_id: str = "TASK-005") -> dict:
+    return make_task(
+        id=task_id,
+        title="Task with agent output",
+        agent_response="line one\nline two",
+    ).model_dump(mode="json")
+
+
+def test_task_json_exposes_agent_response(web_env, registry):
+    server, registry = web_env
+    write_instance(
+        registry,
+        "withoutput",
+        repo=str(registry / "repos" / "withoutput"),
+        tasks=[agent_response_task_json("R-1")],
+    )
+    status, task = _get(
+        f"http://127.0.0.1:{server.port}/api/instances/withoutput/tasks/R-1"
+    )
+    assert status == 200
+    assert task["agent_response"] == "line one\nline two"
+
+    status, tasks = _get(f"http://127.0.0.1:{server.port}/api/instances/withoutput/tasks")
+    assert status == 200
+    assert tasks[0]["agent_response"] == "line one\nline two"
+
+
 def test_reopen_blocked_task(web_env, registry):
     server, registry = web_env
     write_instance(