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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.8.1
+Version: 0.8.2
 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.2}/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.2}/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.2}/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.2}/kolega_code/__init__.py

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

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

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

{kolega_code-0.8.1 → kolega_code-0.8.2}/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.2}/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.2}/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.2}/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.2}/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.2}/kolega_code/agent/tests/test_compaction_tui_events.py

@@ -39,7 +39,8 @@ async def test_compress_history_emits_error_phase_on_failure(tmp_path):
 
 def test_app_apply_compaction_status_toggles_indicator():
     # Exercise the dashboard toggle without constructing the full Textual app.
-    from kolega_code.cli.app import KolegaCodeApp, StatusDashboardState
+    from kolega_code.cli.app import KolegaCodeApp
+    from kolega_code.cli.tui.state import StatusDashboardState
 
     refreshed = []
     fake = SimpleNamespace(
@@ -60,7 +61,8 @@ def test_app_apply_compaction_status_toggles_indicator():
 
 def test_app_apply_compaction_status_adds_summary_collapsible():
     # On finish with a summary, a collapsible transcript entry is created.
-    from kolega_code.cli.app import ConversationEntry, KolegaCodeApp, StatusDashboardState
+    from kolega_code.cli.app import KolegaCodeApp
+    from kolega_code.cli.tui.state import ConversationEntry, StatusDashboardState
 
     added = []
     fake = SimpleNamespace(

{kolega_code-0.8.1 → kolega_code-0.8.2}/kolega_code/agent/tests/test_prompts.py

@@ -1,6 +1,7 @@
 from pathlib import Path
 
 from kolega_code.agent import prompts
+from kolega_code.agent.orchestration.guide import GIGACODE_AUTHORING_GUIDE
 
 
 def test_static_prompt_templates_load() -> None:
@@ -45,6 +46,13 @@ def test_implement_plan_prompt_includes_gigacode_nudge_when_enabled() -> None:
     assert "- [ ] update docs" in rendered
 
 
+def test_gigacode_guide_points_agents_to_artifact_transcripts() -> None:
+    assert "resultPath" in GIGACODE_AUTHORING_GUIDE
+    assert "transcriptPath" in GIGACODE_AUTHORING_GUIDE
+    assert "Never re-run a completed workflow solely" in GIGACODE_AUTHORING_GUIDE
+    assert "READ `resultPath` or `transcriptPath`" in GIGACODE_AUTHORING_GUIDE
+
+
 def test_init_agents_prompt_renders_arguments() -> None:
     rendered = prompts.build_init_agents_prompt("focus on Python packaging")
 

{kolega_code-0.8.1 → kolega_code-0.8.2}/kolega_code/agent/tests/tool_backend/test_workflow_tool.py

@@ -6,7 +6,7 @@ the real run_workflow code path (state-dir resolution, journal, emit, summary).
 
 import json
 from pathlib import Path
-from unittest.mock import AsyncMock, Mock
+from unittest.mock import AsyncMock, Mock, patch
 
 import pytest
 
@@ -29,6 +29,9 @@ def caller():
     c.sub_agent = False
     c.current_tool_execution_id = "exec-1"
     c.current_tool_call_id = "exec-1"
+    c.sub_agent_recorder = None
+    c.prompt_extensions = None
+    c.tool_extensions = None
     c.tool_collection = Mock(read_only=False)  # build-mode (writable) caller by default
     return c
 
@@ -54,8 +57,20 @@ def _stub_dispatch():
     """A dispatch_workflow_agent stub returning (recap, tokens, structured)."""
     calls = []
 
-    async def dispatch_workflow_agent(agent_class, task, *, config=None, schema=None, sub_agent_info_extra=None):
-        calls.append((task, schema, sub_agent_info_extra))
+    async def dispatch_workflow_agent(
+        agent_class,
+        task,
+        *,
+        config=None,
+        schema=None,
+        sub_agent_info_extra=None,
+        artifact_paths=None,
+        artifact_metadata=None,
+    ):
+        calls.append((task, schema, sub_agent_info_extra, artifact_paths, artifact_metadata))
+        if artifact_paths:
+            artifact_paths["jsonl"].write_text(json.dumps({"role": "assistant", "content": task}) + "\n")
+            artifact_paths["markdown"].write_text(f"# Agent artifact\n\n{task}\n")
         if schema:
             return (f"recap:{task}", 7, {"task": task})
         return (f"recap:{task}", 3, None)
@@ -85,14 +100,21 @@ async def test_run_workflow_writes_artifacts_and_summary(workflow_tool):
     assert len(calls) == 4
     assert "Workflow 'demo' completed." in summary
     assert "runId:" in summary and "scriptPath:" in summary
+    assert "resultPath:" in summary
+    assert "transcriptPath:" in summary
 
     # Artifacts under <state_dir>/workflows/<run_id>/
     run_id = next(line.split("runId:")[1].strip() for line in summary.splitlines() if "runId:" in line)
     run_dir = Path(state_dir) / "workflows" / run_id
     assert (run_dir / "script.py").read_text() == SCRIPT
+    assert (run_dir / "result.md").is_file()
+    assert (run_dir / "result.json").is_file()
+    assert (run_dir / "transcript.md").is_file()
+    assert (run_dir / "transcript.jsonl").is_file()
     meta = json.loads((run_dir / "run.json").read_text())
     assert meta["status"] == "completed"
     assert meta["name"] == "demo"
+    assert meta["artifacts"]["resultPath"] == str(run_dir / "result.md")
     # token total = 3*3 (parallel) + 7 (schema) = 16
     assert meta["total_tokens"] == 16
     journal_lines = (run_dir / "journal.jsonl").read_text().splitlines()
@@ -122,6 +144,78 @@ async def test_run_workflow_writes_artifacts_and_summary(workflow_tool):
     assert end["status"] == "completed"
 
 
+@pytest.mark.asyncio
+async def test_long_result_is_persisted_not_truncated_inline(workflow_tool):
+    tool, state_dir = workflow_tool
+    script = 'meta = {"name": "big", "description": "big result"}\nreturn {"blob": "x" * 5001}\n'
+
+    summary = await tool.run_workflow(script=script)
+
+    assert "resultPath:" in summary
+    assert "transcriptPath:" in summary
+    assert "result: written to resultPath" in summary
+    assert "IMPORTANT: The workflow already ran" in summary
+    assert "resultPreview:" not in summary
+    assert "… (truncated)" not in summary
+    assert len(summary) < 100_000
+
+    run_id = next(line.split("runId:")[1].strip() for line in summary.splitlines() if "runId:" in line)
+    run_dir = Path(state_dir) / "workflows" / run_id
+    result_json = json.loads((run_dir / "result.json").read_text())
+    assert result_json["blob"] == "x" * 5001
+    assert "x" * 5001 in (run_dir / "result.md").read_text()
+
+
+@pytest.mark.asyncio
+async def test_readable_transcript_indexes_agent_calls(workflow_tool):
+    tool, state_dir = workflow_tool
+    stub, calls = _stub_dispatch()
+    tool._agent_tool.dispatch_workflow_agent = stub
+    script = (
+        'meta = {"name": "transcript", "description": "d", "phases": [{"title": "Find"}]}\n'
+        'phase("Find")\n'
+        'await agent("alpha", label="alpha-label")\n'
+        'await agent("beta", label="beta-label", phase="Check")\n'
+        'return "done"\n'
+    )
+
+    summary = await tool.run_workflow(script=script)
+
+    assert len(calls) == 2
+    run_id = next(line.split("runId:")[1].strip() for line in summary.splitlines() if "runId:" in line)
+    run_dir = Path(state_dir) / "workflows" / run_id
+    transcript = (run_dir / "transcript.md").read_text()
+    assert "# Workflow transcript: transcript" in transcript
+    assert "alpha-label" in transcript
+    assert "beta-label" in transcript
+    assert "Find" in transcript
+    assert "Check" in transcript
+    # Main workflow transcript should not advertise per-agent transcript paths;
+    # agents should use the main result/transcript and avoid individual sub-agent transcripts.
+    assert "agent-000-alpha-label.md" not in transcript
+    raw_events = [json.loads(line) for line in (run_dir / "transcript.jsonl").read_text().splitlines() if line]
+    assert any(event["type"] == "agent_call" for event in raw_events)
+
+
+@pytest.mark.asyncio
+async def test_failed_agent_call_is_recorded_in_transcript(workflow_tool):
+    tool, state_dir = workflow_tool
+
+    async def failing_dispatch(*args, **kwargs):
+        raise RuntimeError("agent exploded")
+
+    tool._agent_tool.dispatch_workflow_agent = failing_dispatch
+    script = 'meta = {"name": "failure", "description": "d"}\nvalue = await agent("boom", label="boom")\nreturn {"value": value}\n'
+
+    summary = await tool.run_workflow(script=script)
+
+    assert "transcriptPath:" in summary
+    run_id = next(line.split("runId:")[1].strip() for line in summary.splitlines() if "runId:" in line)
+    transcript = (Path(state_dir) / "workflows" / run_id / "transcript.md").read_text()
+    assert "failed" in transcript
+    assert "agent exploded" in transcript
+
+
 @pytest.mark.asyncio
 async def test_run_workflow_carries_phase_and_label_to_dispatch(workflow_tool):
     tool, _ = workflow_tool
@@ -135,12 +229,52 @@ async def test_run_workflow_carries_phase_and_label_to_dispatch(workflow_tool):
         "return 1\n"
     )
     await tool.run_workflow(script=script)
-    _task, _schema, extra = calls[0]
+    _task, _schema, extra, _artifact_paths, _artifact_metadata = calls[0]
     assert extra["phase"] == "Build"
     assert extra["label"] == "my-label"
     assert "workflow_run_id" in extra
 
 
+@pytest.mark.asyncio
+async def test_per_agent_markdown_and_jsonl_are_written(workflow_tool):
+    tool, state_dir = workflow_tool
+
+    class ArtifactAgent:
+        agent_name = "artifact-agent"
+
+        def __init__(self, **kwargs):
+            self.total_tokens_used = 11
+            self._history = [
+                {"role": "user", "content": [{"type": "text", "text": "artifact task"}]},
+                {"role": "assistant", "content": [{"type": "text", "text": "artifact answer"}]},
+            ]
+
+        async def process_message_stream(self, task):
+            yield {"type": "response", "content": "artifact answer", "complete": True, "uuid": "u1"}
+
+        def dump_message_history(self):
+            return self._history
+
+        async def recap_agent_outcome(self):
+            return "final artifact recap"
+
+    script = 'meta = {"name": "agent-artifacts", "description": "d"}\nreturn await agent("artifact task", label="artifact")\n'
+
+    with patch("kolega_code.agent.generalagent.GeneralAgent", ArtifactAgent):
+        summary = await tool.run_workflow(script=script)
+
+    run_id = next(line.split("runId:")[1].strip() for line in summary.splitlines() if "runId:" in line)
+    agents_dir = Path(state_dir) / "workflows" / run_id / "agents"
+    markdown = agents_dir / "agent-000-artifact.md"
+    raw = agents_dir / "agent-000-artifact.jsonl"
+    assert markdown.is_file()
+    assert raw.is_file()
+    markdown_text = markdown.read_text()
+    assert "artifact task" in markdown_text
+    assert "final artifact recap" in markdown_text
+    assert "artifact answer" in raw.read_text()
+
+
 @pytest.mark.asyncio
 async def test_resume_replays_without_redispatch(workflow_tool):
     tool, state_dir = workflow_tool
@@ -155,6 +289,10 @@ async def test_resume_replays_without_redispatch(workflow_tool):
     summary2 = await tool.run_workflow(script=SCRIPT, resume_from_run_id=run_id)
     assert len(calls) == 0  # fully replayed from journal
     assert "completed" in summary2
+    run_id2 = next(line.split("runId:")[1].strip() for line in summary2.splitlines() if "runId:" in line)
+    transcript2 = (Path(state_dir) / "workflows" / run_id2 / "transcript.md").read_text()
+    assert "Cached resume calls" in transcript2
+    assert "served from resume cache" in transcript2
 
 
 @pytest.mark.asyncio
@@ -166,7 +304,7 @@ async def test_read_only_caller_forces_investigation_agents(workflow_tool, calle
 
     seen = []
 
-    async def stub(agent_class, task, *, config=None, schema=None, sub_agent_info_extra=None):
+    async def stub(agent_class, task, *, config=None, schema=None, sub_agent_info_extra=None, **kwargs):
         seen.append(agent_class.__name__)
         return (f"recap:{task}", 1, None)