kolega-code 0.8.1__tar.gz → 0.8.3__tar.gz

{kolega_code-0.8.1 → kolega_code-0.8.3}/.github/workflows/ci.yml

@@ -43,4 +43,4 @@ jobs:
         run: uv sync --extra dev --frozen
 
       - name: Run fast tests
-        run: uv run pytest -ra --durations=50 --import-mode=importlib -m "not slow"
+        run: ./run_tests.sh

{kolega_code-0.8.1 → kolega_code-0.8.3}/CONTRIBUTING.md

@@ -46,7 +46,7 @@ Run slow and integration tests only when you have the required credentials:
 You can pass additional pytest arguments through the wrapper:
 
 ```bash
-./run_tests.sh kolega_code/agent/tests/llm/test_client.py -ra
+./run_tests.sh tests/agent/llm/test_client.py -ra
 ```
 
 ## Documentation

{kolega_code-0.8.1 → kolega_code-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.8.1
+Version: 0.8.3
 Summary: Local-first AI coding agent for the terminal
 Project-URL: Homepage, https://kolega-ai.github.io/kolega-code/
 Project-URL: Documentation, https://kolega-ai.github.io/kolega-code/

{kolega_code-0.8.1 → kolega_code-0.8.3}/RELEASING.md

@@ -29,7 +29,7 @@ release branch.
 3. Run the fast test suite:
 
    ```bash
-   uv run pytest -ra --durations=50 --import-mode=importlib -m "not slow"
+   ./run_tests.sh
    ```
 
 4. Commit the release bump and open a pull request against `main`:

{kolega_code-0.8.1 → kolega_code-0.8.3}/docs/src/content/docs/cli/overview.md

@@ -39,6 +39,7 @@ kolega-code [PROJECT_PATH]
 | `--new` | Start a new session (this is the default) |
 | `--resume [THREAD_ID]` | Resume the latest saved thread, or a specific thread/session ID |
 | `--browser-visible` | Launch visible Playwright browser windows instead of headless |
+| `--show-logs` | Show the optional diagnostic Logs side-panel tab. Hidden by default to avoid unnecessary log rendering work |
 | `--permission-mode <auto\|ask>` | Shell/edit permission mode. TUI sessions default to `ask` |
 | `--session <ID>` | Legacy alias for `--resume THREAD_ID` |
 

{kolega_code-0.8.1 → kolega_code-0.8.3}/docs/src/content/docs/gigacode.mdx

@@ -43,6 +43,15 @@ When the agent runs a workflow, the transcript shows **phase headers** and short
 [sub-agent inspector](../tui/interface/#sub-agent-inspector) — press `Ctrl+G` to
 watch every agent's live trajectory, grouped by phase.
 
+The `run_workflow` result is a compact artifact manifest. It includes paths like
+`resultPath` and `transcriptPath`; the completed workflow result is written to
+`resultPath` instead of returned inline. For normal workflow output, the agent
+should read those main files and avoid reading individual sub-agent transcripts.
+Raw and per-agent debug artifacts may exist under the run directory for explicit
+workflow debugging.
+The agent should read those paths first — not re-run the workflow just to recover
+output text.
+
 ## How it works
 
 Under the hood, the agent authors a short **Python script** and runs it with a
@@ -69,9 +78,11 @@ return findings
 
 <Aside type="note">
 Workflows are deterministic and **resumable**. Each run is saved under Kolega
-Code's state directory (`workflows/<run-id>/`) with its script, a journal, and each
-sub-agent's transcript, so an interrupted run can pick up where it left off instead
-of redoing finished work.
+Code's state directory (`workflows/<run-id>/`) with its script, full result files,
+a readable Markdown transcript, raw JSONL, a resume journal, and debug sub-agent
+transcripts, so an interrupted run can pick up where it left off instead of redoing
+finished work. Use resume when intentionally iterating on the workflow; use the
+artifact paths when you only need to inspect output.
 </Aside>
 
 ## Behavior and safety

{kolega_code-0.8.1 → kolega_code-0.8.3}/docs/src/content/docs/tui/interface.md

@@ -14,8 +14,9 @@ The screen is split into two columns:
 - **Conversation panel** (left, larger) — your chat with the agent. Responses
   stream in live, tool calls and sub-agent activity appear inline, and detailed
   tool results are collapsed by default so you can expand only what you need.
-- **Side panel** (right) — a set of tabs for status, logs, the terminal, planning,
-  and settings. Toggle it with `Ctrl+O` or `/sidebar`.
+- **Side panel** (right) — a set of tabs for status, the terminal, planning,
+  and settings. Toggle it with `Ctrl+O` or `/sidebar`. The diagnostic Logs tab is
+  opt-in; launch with `--show-logs` when you want it.
 
 At the bottom sits the **composer** — the text box where you type prompts. See
 [Chat Composer](../composer/) for everything it can do.
@@ -25,7 +26,7 @@ At the bottom sits the **composer** — the text box where you type prompts. See
 | Tab | What it shows |
 | --- | --- |
 | **Status** | The active provider/model and thinking effort, the current interaction mode (Build/Plan), permission mode, the agent's turn state (idle, generating, thinking, running a tool, running sub-agents, waiting for input, …), token usage, and context warnings. |
-| **Logs** | A timestamped, color-coded activity log: sub-agent lifecycle, tool calls, configuration changes. An indicator flags new entries when you're on another tab. |
+| **Logs** | Optional. Launch with `--show-logs` to show a timestamped, color-coded diagnostic activity log. New entries preserve manual scrollback and an indicator flags unseen entries when you're on another tab. |
 | **Terminal** | Live output from commands the agent runs. |
 | **Planning** | The current **Plan** (markdown from the planning agent) and the shared **Task List** that both modes can edit. |
 | **Settings** | Provider, model, thinking effort, and API-key configuration. See [Settings & API Keys](../../configuration/settings-and-api-keys/). |

{kolega_code-0.8.1 → kolega_code-0.8.3}/kolega_code/__init__.py

@@ -151,4 +151,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.8.1"
+__version__ = "0.8.3"

{kolega_code-0.8.1 → kolega_code-0.8.3}/kolega_code/agent/__init__.py

@@ -44,4 +44,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.8.1"
+__version__ = "0.8.3"

{kolega_code-0.8.1 → kolega_code-0.8.3}/kolega_code/agent/orchestration/guide.py

@@ -134,10 +134,26 @@ After the workflow returns, integrate the results, run the full test suite yours
 report. If the plan is small or its parts are tightly coupled, skip the workflow and just
 implement it directly — orchestration is for genuinely independent fan-out.
 
+### Artifacts and transcripts
+
+`run_workflow` returns a concise manifest, not necessarily the full workflow output.
+Every completed run persists full artifacts under the state directory and returns
+paths including `resultPath` and `transcriptPath`. If the inline tool result says output was omitted, looks incomplete,
+or would require a long transcript to understand, READ `resultPath` or `transcriptPath`
+with the file-reading tools before deciding work is missing. For normal workflow
+output, use only those main files; avoid reading individual sub-agent transcripts
+unless you are explicitly debugging workflow execution.
+
+Never re-run a completed workflow solely to recover output from an omitted/truncated
+inline result. The workflow already ran; inspect the persisted result/transcript first.
+Use `resume_from_run_id` only when you intentionally want to iterate on or change the
+workflow, not as a transcript-recovery mechanism.
+
 ### Resume
 
-Each run persists its script and a journal under the state directory and returns a
-`runId` and `scriptPath`. To iterate, edit the script and re-run with `script_path`,
-or pass `resume_from_run_id` to replay cached `agent()` results for the unchanged
-prefix and only re-run new/changed calls.
+Each run persists its script, full results, a readable transcript, raw JSONL, and a
+resume journal under the state directory and returns a `runId` plus artifact paths.
+To iterate, edit the script and re-run with `script_path`, or pass `resume_from_run_id`
+to replay cached `agent()` results for the unchanged prefix and only re-run new/changed
+calls.
 """

{kolega_code-0.8.1 → kolega_code-0.8.3}/kolega_code/agent/orchestration/journal.py

@@ -4,9 +4,13 @@ Everything a run needs lives under::
 
     <state-dir>/workflows/<run_id>/
         script.py        the authored source (its path is returned for edit + re-run)
-        run.json         meta, args, status, timing, token totals
+        run.json         meta, args, status, timing, token totals, artifact paths
         journal.jsonl    one line per completed agent() call (drives resume)
-        agents/          per sub-agent transcripts (wired via sub_agent_recorder)
+        result.json      full JSON-rendered workflow return value
+        result.md        readable workflow return value
+        transcript.jsonl raw workflow events/call outcomes
+        transcript.md    readable workflow transcript/index
+        agents/          per sub-agent raw/readable transcripts
 
 Resume contract: scripts are deterministic (the runtime blocks ``random``/``time``
 and ``import``), so the same source + args produce ``agent()`` calls in the same
@@ -18,6 +22,7 @@ new call onward.
 from __future__ import annotations
 
 import json
+import re
 from pathlib import Path
 from typing import Any, Dict, Optional, Tuple
 
@@ -32,6 +37,15 @@ def saved_workflows_dir(state_dir: Path) -> Path:
     return workflows_root(state_dir) / "_saved"
 
 
+def _slugify(value: str, *, fallback: str = "agent", max_length: int = 64) -> str:
+    """Return a filesystem-friendly slug for workflow artifact filenames."""
+    slug = re.sub(r"[^A-Za-z0-9._-]+", "-", str(value or "").strip().lower())
+    slug = re.sub(r"-+", "-", slug).strip("-._")
+    if not slug:
+        slug = fallback
+    return slug[:max_length].rstrip("-._") or fallback
+
+
 class RunJournal:
     """Owns the on-disk artifacts for a single workflow run."""
 
@@ -40,6 +54,10 @@ class RunJournal:
         self.run_id = run_id
         self.agents_dir = self.run_dir / "agents"
         self._journal_path = self.run_dir / "journal.jsonl"
+        self._transcript_jsonl_path = self.run_dir / "transcript.jsonl"
+        self._transcript_md_path = self.run_dir / "transcript.md"
+        self._result_json_path = self.run_dir / "result.json"
+        self._result_md_path = self.run_dir / "result.md"
         self._script_path = self.run_dir / "script.py"
         self._meta_path = self.run_dir / "run.json"
 
@@ -55,6 +73,33 @@ class RunJournal:
     def script_path(self) -> Path:
         return self._script_path
 
+    @property
+    def journal_path(self) -> Path:
+        return self._journal_path
+
+    @property
+    def transcript_jsonl_path(self) -> Path:
+        return self._transcript_jsonl_path
+
+    @property
+    def transcript_md_path(self) -> Path:
+        return self._transcript_md_path
+
+    @property
+    def result_json_path(self) -> Path:
+        return self._result_json_path
+
+    @property
+    def result_md_path(self) -> Path:
+        return self._result_md_path
+
+    def agent_artifact_paths(self, call_index: int, label: Optional[str] = None) -> Dict[str, Path]:
+        """Return stable per-agent raw/readable artifact paths for a workflow call."""
+        self.ensure_dirs()
+        suffix = _slugify(label or f"call-{call_index}")
+        stem = f"agent-{call_index:03d}-{suffix}"
+        return {"markdown": self.agents_dir / f"{stem}.md", "jsonl": self.agents_dir / f"{stem}.jsonl"}
+
     def write_script(self, source: str) -> Path:
         self.ensure_dirs()
         self._script_path.write_text(source, encoding="utf-8")
@@ -86,16 +131,41 @@ class RunJournal:
         label: Optional[str],
         value: Any,
         status: str = "completed",
+        **metadata: Any,
     ) -> None:
-        """Append one completed ``agent()`` result for resume replay."""
+        """Append one completed ``agent()`` result for resume replay.
+
+        ``journal.jsonl`` is the resume contract. Extra fields are allowed and ignored
+        by ``load_cache()`` so newer artifact metadata remains backward-compatible.
+        """
         self.ensure_dirs()
-        line = json.dumps(
-            {"index": call_index, "key": key, "label": label, "status": status, "value": value},
-            default=str,
-        )
+        payload = {"index": call_index, "key": key, "label": label, "status": status, "value": value}
+        payload.update({k: v for k, v in metadata.items() if v is not None})
+        line = json.dumps(payload, default=str)
         with self._journal_path.open("a", encoding="utf-8") as handle:
             handle.write(line + "\n")
 
+    def append_transcript_event(self, event: Dict[str, Any]) -> None:
+        """Append one raw workflow transcript event as JSONL."""
+        self.ensure_dirs()
+        with self._transcript_jsonl_path.open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(event, default=str) + "\n")
+
+    def write_result_artifacts(self, result: Any, markdown: str) -> None:
+        """Persist the full workflow return value in JSON and readable Markdown."""
+        self.ensure_dirs()
+        try:
+            rendered_json = json.dumps(result, indent=2, default=str)
+        except (TypeError, ValueError):
+            rendered_json = json.dumps(str(result), indent=2)
+        self._result_json_path.write_text(rendered_json + "\n", encoding="utf-8")
+        self._result_md_path.write_text(markdown, encoding="utf-8")
+
+    def write_transcript_markdown(self, markdown: str) -> None:
+        """Persist the readable workflow transcript."""
+        self.ensure_dirs()
+        self._transcript_md_path.write_text(markdown, encoding="utf-8")
+
     def load_cache(self) -> Dict[int, Tuple[str, Any]]:
         """Read a prior run's journal into ``{call_index: (key, value)}``.
 

{kolega_code-0.8.1 → kolega_code-0.8.3}/kolega_code/agent/orchestration/runtime.py

@@ -150,8 +150,19 @@ class WorkflowRuntime:
 
         cached = self._resume_cache.get(index)
         if cached is not None and cached[0] == key:
-            self._emit_soon("workflow_agent_cached", {"label": spec.label or prompt[:60], "phase": spec.phase})
-            return cached[1]
+            cached_value = cached[1]
+            label = spec.label or prompt[:60]
+            self._journal.append_transcript_event(
+                {
+                    "type": "agent_cached",
+                    "index": index,
+                    "label": label,
+                    "phase": spec.phase,
+                    "value": cached_value,
+                }
+            )
+            self._emit_soon("workflow_agent_cached", {"label": label, "phase": spec.phase})
+            return cached_value
 
         self._agent_count += 1
         if self._agent_count > self._agent_cap:
@@ -169,7 +180,34 @@ class WorkflowRuntime:
 
         self.budget.add(result.tokens)
         value = result.value
-        self._journal.record(index, key, spec.label, value, status=result.status)
+        self._journal.record(
+            index,
+            key,
+            spec.label,
+            value,
+            status=result.status,
+            phase=spec.phase,
+            agent_type=spec.agent_type,
+            tokens=result.tokens,
+            error=result.error,
+            transcript_path=result.transcript_path,
+            transcript_markdown_path=result.transcript_markdown_path,
+        )
+        self._journal.append_transcript_event(
+            {
+                "type": "agent_call",
+                "index": index,
+                "label": spec.label,
+                "phase": spec.phase,
+                "agent_type": spec.agent_type,
+                "status": result.status,
+                "tokens": result.tokens,
+                "error": result.error,
+                "value": value,
+                "transcript_path": result.transcript_path,
+                "transcript_markdown_path": result.transcript_markdown_path,
+            }
+        )
         return value
 
     async def parallel(self, thunks: Iterable[Callable[[], Awaitable[Any]]]) -> List[Any]:

{kolega_code-0.8.1 → kolega_code-0.8.3}/kolega_code/agent/orchestration/types.py

@@ -56,6 +56,8 @@ class AgentRunResult:
     agent_id: Optional[str] = None
     status: str = "completed"  # completed | failed | skipped
     error: Optional[str] = None
+    transcript_path: Optional[str] = None
+    transcript_markdown_path: Optional[str] = None
 
     @property
     def value(self) -> Any:

{kolega_code-0.8.1 → kolega_code-0.8.3}/kolega_code/agent/prompt_templates/system/agents/coder_cli.md.j2

@@ -46,6 +46,10 @@ Do not run destructive commands automatically. Treat commands that delete files,
 
 When running tests or builds, choose the smallest command that gives confidence first, then broaden verification when the change has a wider blast radius.
 
+## Git Branches and Pull Requests
+
+When creating a branch or opening a pull request, follow repository or user conventions if provided; otherwise use Conventional Commits-style names. Use lowercase kebab-case branch names with a conventional type prefix, such as `feat/add-login-rate-limit` or `fix/navbar-overlap`. Use Conventional Commit PR titles, such as `feat(auth): add session timeout` or `fix: handle empty search results`. Keep names descriptive but not overly long.
+
 ## Development Servers
 
 When starting a local development server, use an available port and tell the user the URL. If a server is already running on the default port, use another suitable port. Stop servers you started when they are no longer needed unless the user is actively testing them.

{kolega_code-0.8.1 → kolega_code-0.8.3}/kolega_code/agent/tool_backend/agent_tool.py

@@ -1,7 +1,8 @@
 import uuid
 import inspect
+import json
 from pathlib import Path
-from typing import Union, Optional
+from typing import Any, Union, Optional
 from datetime import datetime, timezone
 import time
 
@@ -561,6 +562,105 @@ class AgentTool(BaseTool):
             max_iterations=getattr(self.caller, "max_iterations", None),
         )
 
+    @staticmethod
+    def _write_jsonl_message(path: Optional[Path], message: dict) -> None:
+        if path is None:
+            return
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(message, default=str) + "\n")
+
+    @staticmethod
+    def _render_workflow_message(message: dict) -> str:
+        role = str(message.get("role") or "message")
+        content = message.get("content", "")
+        lines = [f"### {role}", ""]
+        if isinstance(content, str):
+            lines.append(content)
+        elif isinstance(content, list):
+            for item in content:
+                if isinstance(item, dict):
+                    item_type = item.get("type", "content")
+                    if item_type == "text":
+                        lines.append(str(item.get("text", "")))
+                    elif item_type == "tool_use":
+                        lines.append(f"**Tool use:** `{item.get('name', '')}`")
+                        lines.append("```json")
+                        lines.append(json.dumps(item.get("input", {}), indent=2, default=str))
+                        lines.append("```")
+                    elif item_type == "tool_result":
+                        status = "Error" if item.get("is_error") else "Result"
+                        lines.append(f"**Tool {status}:** `{item.get('name', '')}`")
+                        lines.append("```")
+                        lines.append(str(item.get("content", "")))
+                        lines.append("```")
+                    else:
+                        lines.append("```json")
+                        lines.append(json.dumps(item, indent=2, default=str))
+                        lines.append("```")
+                else:
+                    rendered = item.to_markdown() if hasattr(item, "to_markdown") else str(item)
+                    lines.append(rendered)
+        else:
+            lines.append(str(content))
+        return "\n".join(lines).rstrip() + "\n"
+
+    @staticmethod
+    def _render_value_markdown(value: Any) -> str:
+        if value is None:
+            return "None"
+        if isinstance(value, str):
+            return value
+        try:
+            return "```json\n" + json.dumps(value, indent=2, default=str) + "\n```"
+        except (TypeError, ValueError):
+            return str(value)
+
+    def _write_workflow_agent_markdown(
+        self,
+        artifact_paths: Optional[dict],
+        *,
+        metadata: dict,
+        prompt: str,
+        status: str,
+        result: Optional[str] = None,
+        structured: Any = None,
+        tokens: int = 0,
+        error: Optional[str] = None,
+        history: Optional[list[dict]] = None,
+    ) -> None:
+        if not artifact_paths or not artifact_paths.get("markdown"):
+            return
+        path = Path(artifact_paths["markdown"])
+        path.parent.mkdir(parents=True, exist_ok=True)
+        lines = [
+            f"# Workflow agent {metadata.get('call_index', '')}: {metadata.get('label') or metadata.get('agent_name') or 'agent'}",
+            "",
+            "## Metadata",
+            "",
+            f"- Call index: {metadata.get('call_index', '')}",
+            f"- Label: {metadata.get('label') or ''}",
+            f"- Phase: {metadata.get('phase') or ''}",
+            f"- Agent type: {metadata.get('agent_type') or metadata.get('agent_name') or ''}",
+            f"- Status: {status}",
+            f"- Tokens: {tokens}",
+        ]
+        if error:
+            lines.append(f"- Error: {error}")
+        jsonl_path = artifact_paths.get("jsonl")
+        if jsonl_path:
+            lines.append(f"- Raw transcript: `{jsonl_path}`")
+        lines.extend(["", "## Task prompt", "", prompt.strip() or "(empty)"])
+        if structured is not None:
+            lines.extend(["", "## Structured result", "", self._render_value_markdown(structured)])
+        if result is not None:
+            lines.extend(["", "## Final recap", "", result])
+        if history:
+            lines.extend(["", "## Message history", ""])
+            for message in history:
+                lines.append(self._render_workflow_message(message))
+        path.write_text("\n".join(lines).rstrip() + "\n", encoding="utf-8")
+
     async def dispatch_workflow_agent(
         self,
         agent_class,
@@ -569,6 +669,8 @@ class AgentTool(BaseTool):
         config=None,
         schema: Optional[dict] = None,
         sub_agent_info_extra: Optional[dict] = None,
+        artifact_paths: Optional[dict] = None,
+        artifact_metadata: Optional[dict] = None,
     ):
         """Dispatch one sub-agent for a gigacode workflow.
 
@@ -609,6 +711,16 @@ class AgentTool(BaseTool):
         if sub_agent_info_extra:
             sub_agent_info.update({k: v for k, v in sub_agent_info_extra.items() if v is not None})
 
+        artifact_metadata = dict(artifact_metadata or {})
+        artifact_metadata.setdefault("agent_name", agent_name)
+        if artifact_paths:
+            for key in ("markdown", "jsonl"):
+                if artifact_paths.get(key):
+                    artifact_paths[key] = Path(artifact_paths[key])
+            if artifact_paths.get("jsonl"):
+                artifact_paths["jsonl"].parent.mkdir(parents=True, exist_ok=True)
+                artifact_paths["jsonl"].write_text("", encoding="utf-8")
+
         capture: dict = {}
         extra_extensions = []
         effective_task = task
@@ -618,6 +730,7 @@ class AgentTool(BaseTool):
 
         await self._send_status_event("GENERATING", f"Starting {agent_name} task", sub_agent_info=sub_agent_info)
         conversation_finished = False
+        agent = None
 
         try:
             agent = self._construct_workflow_sub_agent(agent_class, config, extra_extensions)
@@ -627,7 +740,13 @@ class AgentTool(BaseTool):
             agent.sub_agent_context = sub_agent_info
 
             last_saved_index = await self._stream_workflow_agent(
-                agent, agent_name, sub_agent_info, conversation_id, last_saved_index=-1, task=effective_task
+                agent,
+                agent_name,
+                sub_agent_info,
+                conversation_id,
+                last_saved_index=-1,
+                task=effective_task,
+                artifact_jsonl_path=artifact_paths.get("jsonl") if artifact_paths else None,
             )
 
             # Single re-prompt if a schema was requested but submit_result wasn't called.
@@ -639,6 +758,7 @@ class AgentTool(BaseTool):
                     conversation_id,
                     last_saved_index=last_saved_index,
                     task=self._STRUCTURED_OUTPUT_NUDGE,
+                    artifact_jsonl_path=artifact_paths.get("jsonl") if artifact_paths else None,
                 )
 
             result = await agent.recap_agent_outcome()
@@ -664,6 +784,21 @@ class AgentTool(BaseTool):
             )
 
             structured = capture.get("value") if schema else None
+            final_history = agent.dump_message_history() if agent is not None else []
+            if artifact_paths and artifact_paths.get("jsonl"):
+                # Persist any history messages that completed after the last stream event.
+                for i in range(last_saved_index + 1, len(final_history)):
+                    self._write_jsonl_message(artifact_paths.get("jsonl"), final_history[i])
+            self._write_workflow_agent_markdown(
+                artifact_paths,
+                metadata=artifact_metadata,
+                prompt=task,
+                status="completed",
+                result=result,
+                structured=structured,
+                tokens=total_tokens if isinstance(total_tokens, int) else 0,
+                history=final_history,
+            )
             return result, (total_tokens if isinstance(total_tokens, int) else 0), structured
 
         except Exception as e:
@@ -678,6 +813,20 @@ class AgentTool(BaseTool):
                     },
                 )
                 conversation_finished = True
+            final_history = []
+            if agent is not None:
+                try:
+                    final_history = agent.dump_message_history()
+                except Exception:  # noqa: BLE001 - transcript capture must not mask the real failure
+                    final_history = []
+            self._write_workflow_agent_markdown(
+                artifact_paths,
+                metadata=artifact_metadata,
+                prompt=task,
+                status="failed",
+                error=str(e),
+                history=final_history,
+            )
             await self.log_error(f"Error in workflow {agent_name}: {str(e)}", sender="AgentTool")
             await self._send_status_event("ERROR", f"Error in {agent_name}: {str(e)}", sub_agent_info=sub_agent_info)
             raise
@@ -704,6 +853,7 @@ class AgentTool(BaseTool):
         *,
         last_saved_index: int,
         task: str,
+        artifact_jsonl_path: Optional[Path] = None,
     ) -> int:
         """Stream one process_message_stream pass, broadcasting events and recording
         newly-completed history messages. Returns the updated last_saved_index.
@@ -729,19 +879,21 @@ class AgentTool(BaseTool):
             )
             await self.connection_manager.broadcast_event(evt, self.workspace_id, self.thread_id)
 
-            if conversation_id and complete:
+            if complete:
                 current_history = agent.dump_message_history()
                 for i in range(last_saved_index + 1, len(current_history)):
                     hist_msg = current_history[i]
-                    await self._record_message(
-                        conversation_id,
-                        {
-                            "role": hist_msg.get("role", "assistant"),
-                            "content": hist_msg.get("content", []),
-                            "stream_uuid": None,
-                        },
-                        i + 1,
-                    )
+                    if conversation_id:
+                        await self._record_message(
+                            conversation_id,
+                            {
+                                "role": hist_msg.get("role", "assistant"),
+                                "content": hist_msg.get("content", []),
+                                "stream_uuid": None,
+                            },
+                            i + 1,
+                        )
+                    self._write_jsonl_message(artifact_jsonl_path, hist_msg)
                 last_saved_index = len(current_history) - 1
 
         return last_saved_index