agent-postmortem 0.3.5__tar.gz → 0.3.6__tar.gz

{agent_postmortem-0.3.5 → agent_postmortem-0.3.6}/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.6]
+
+### Fixed
+
+- The default (share) output could print an agent's own label. A story sentence starts with
+  a capital, and when an agent's whole story was its interrupt finding, whose title starts
+  with the label, the label was capitalized before the name substitution ran. That
+  substitution matched names case-sensitively, so a workflow label such as `impl:t2` or a
+  subagent description starting with a lowercase letter printed as `Impl:t2` in the
+  STORIES section of `run` and in `stories[].text` of `run --json`. A story clause is now
+  capitalized after its names are replaced, so it reads `Agent-1 interrupted after ...`.
+  `scan`, `run --bug-report`, `rescue` and the hook messages never carried it, and none of
+  the 382 runs on the maintainer's machine hit it. `--local` and `--raw` are unchanged.
+
 ## [0.3.5]
 
 ### Changed

{agent_postmortem-0.3.5 → agent_postmortem-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agent-postmortem
-Version: 0.3.5
+Version: 0.3.6
 Summary: Reads the Claude Code logs already on your machine and tells you which agent's 'done' you can't trust, and what to run next.
 Project-URL: Homepage, https://github.com/zeyusuntt/agent-postmortem
 Project-URL: Issues, https://github.com/zeyusuntt/agent-postmortem/issues

{agent_postmortem-0.3.5 → agent_postmortem-0.3.6}/docs/DESIGN.md

@@ -4742,7 +4742,19 @@ trend row's target) and `Finding.title`, rendered through `Redactor.title()`
 followed by structural `redact()`; **(N3b S1)** names come first, so a label
 that holds a UUID, an email, or a `-Users-...` slug is replaced whole
 instead of being half-rewritten by the structural pass and then missed)
-work exactly as before. Evidence, a diagnostic, and a metrics value are
+work exactly as before. **(0.3.6)** A story clause is capitalized only after the sink
+substituted names in it (`report._render_pieces` renders each `_Clause` through
+`Redactor.title`, then upper-cases its first character), so a name meets the pattern as
+written and becomes `Agent-1` at a sentence start. Through 0.3.5 the clause was capitalized
+first: a `mislabeled_kill` title starts with the label, and when it was an agent's whole
+story the label `impl:x` reached share output as `Impl:x`, which the case-sensitive pattern
+never matched (`run` text and `run --json` stories only; `tests/test_share_label_case.py`).
+Matching stays case-sensitive, and every clause in the tool's own words is written with
+its capital already (`report._own_clause`: "Killed 1 time by the runtime", "Attempt 2
+failed: ...", "Wrote no paths."), so a label that is a plain word (`killed`, `attempt`,
+`wrote`) never rewrites them, and neither are finding titles, except the title of a
+detector that leads with its agent's own label (`report._LABEL_LED_TITLES`:
+`mislabeled_kill`), which is capitalized only after the substitution. Evidence, a diagnostic, and a metrics value are
 never fed to the five *name* categories (agent/desc/phase/type/target): they
 pass through structural `redact()` alone (plain `Redactor.__call__`),
 because they are a faithful quote of transcript text (4.5), not a rendered
@@ -6707,7 +6719,7 @@ later events go positional).
 
 ### 8.1 Package
 
-`pyproject.toml`: name `agent-postmortem`, version `0.3.5`, console scripts
+`pyproject.toml`: name `agent-postmortem`, version `0.3.6`, console scripts
 `agent-postmortem` and `postmortem`, `requires-python >= 3.11`, no runtime
 dependencies, `[project.optional-dependencies].dev = ["pytest>=8",
 "ruff>=0.6"]`, classifiers, URLs (Homepage, Issues, Changelog). The wheel

{agent_postmortem-0.3.5 → agent_postmortem-0.3.6}/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-postmortem",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "Reads the Claude Code logs already on your machine and tells you which agent's 'done' you can't trust, and what to run next.",
   "author": {
     "name": "zeyusuntt",

{agent_postmortem-0.3.5 → agent_postmortem-0.3.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-postmortem"
-version = "0.3.5"
+version = "0.3.6"
 description = "Reads the Claude Code logs already on your machine and tells you which agent's 'done' you can't trust, and what to run next."
 readme = "README.md"
 license = { text = "MIT" }

{agent_postmortem-0.3.5 → agent_postmortem-0.3.6}/src/agent_postmortem/__init__.py

@@ -6,4 +6,4 @@ plugin/.claude-plugin/plugin.json's version (docs/DESIGN.md 7.1's D1,
 enforced by tests/test_plugin.py).
 """
 
-__version__ = "0.3.5"
+__version__ = "0.3.6"

{agent_postmortem-0.3.5 → agent_postmortem-0.3.6}/src/agent_postmortem/report.py

@@ -1759,9 +1759,11 @@ def _agent_story_pieces(agent, agent_findings: list[Finding]) -> list:
                 all_runtime = False
         if all_runtime and silences:
             silence_text = ", ".join(silences)
-            lead = f"killed {k} {_plural(k, 'time')} by the runtime ({silence_text} of silence)"
+            lead = _own_clause(
+                f"killed {k} {_plural(k, 'time')} by the runtime ({silence_text} of silence)"
+            )
         else:
-            lead = f"restarted {k} {_plural(k, 'time')}"
+            lead = _own_clause(f"restarted {k} {_plural(k, 'time')}")
 
     parent_stop = False
     if final is not None:
@@ -1773,13 +1775,13 @@ def _agent_story_pieces(agent, agent_findings: list[Finding]) -> list:
     elif lead is not None:
         clauses.append(lead)
     elif parent_stop:
-        clauses.append("stopped by the parent")
+        clauses.append(_own_clause("stopped by the parent"))
 
     for finding in by_detector.get("attempt_failed", []):
         ordinal = _finding_ordinal(finding, attempts_sorted)
         phrase = _cause_phrase(finding.metrics.get("cause", "unattributed"))
         reset_time = finding.metrics.get("reset_time")
-        text = f"attempt {ordinal} failed: {phrase}"
+        text = _own_clause(f"attempt {ordinal} failed: {phrase}")
         if reset_time:
             text += f", resets {reset_time}"
         clauses.append(text)
@@ -1787,7 +1789,9 @@ def _agent_story_pieces(agent, agent_findings: list[Finding]) -> list:
     for finding in by_detector.get("claim_contradiction", []):
         ordinal = _finding_ordinal(finding, attempts_sorted)
         phrases = _claim_contradiction_phrases(finding.metrics)
-        clauses.append(f"attempt {ordinal} completed but reported {'; '.join(phrases)}")
+        clauses.append(
+            _own_clause(f"attempt {ordinal} completed but reported {'; '.join(phrases)}")
+        )
 
     _paths_display, commits_count = _agent_facts_totals(agent)
     path_count, paths_partial = _agent_paths(agent)
@@ -1818,30 +1822,68 @@ def _agent_story_pieces(agent, agent_findings: list[Finding]) -> list:
         clauses.append("; ".join(tooling_bits))
 
     if not clauses and agent_findings:
-        clauses.append(agent_findings[0].title_parts or agent_findings[0].title)
+        clauses.append(_title_clause(agent_findings[0], agent.label))
 
     return _sentences_pieces(clauses)
 
 
+def _sentence_case(text: str) -> str:
+    """`text` with its first character upper-cased: how a story sentence starts."""
+    return text[:1].upper() + text[1:]
+
+
+def _own_clause(text: str) -> str:
+    """A story clause in the tool's own words, capitalized where it is written (0.4 review round
+    2): every clause is capitalized again only after names are substituted, and a label that is
+    the clause's first word (`killed`, `restarted`, `attempt`) must not meet that word in
+    lowercase."""
+    return _sentence_case(text)
+
+
+# Detectors whose title starts with the agent's own label ("<label> interrupted after ...").
+_LABEL_LED_TITLES = frozenset({"mislabeled_kill"})
+
+
+def _title_clause(finding: Finding, label: str | None) -> object:
+    """A finding title as a story clause (0.3.6 review round 3). The title of a detector that
+    leads with the agent's own label stays as written, so the name substitution meets the label
+    before the sentence is capitalized; every other title is in the tool's own words and is
+    capitalized where it is used (`_own_clause`), so a label that is its first word ("the" in
+    "the harness reported this workflow failed") never rewrites it."""
+    if finding.title_parts:
+        return finding.title_parts
+    title = finding.title
+    if (
+        finding.detector in _LABEL_LED_TITLES
+        and isinstance(label, str) and label and title.startswith(label)
+    ):
+        return title
+    return _own_clause(title)
+
+
+class _Clause(str):
+    """A story clause as written, without its final period. Its first character is upper-cased
+    only after a sink rendered it (0.3.6): a clause can start with a user-authored name (a
+    `mislabeled_kill` title starts with the label), and the case-sensitive name substitution
+    must meet that name as written (docs/DESIGN.md 5.1)."""
+
+
 def _sentences(clauses: list[str]) -> str:
     """Join clauses as sentences: each starts with a capital and the whole
     ends with one period. Finding titles start lowercase by convention
     (docs/DESIGN.md 4.3), so this is where a story gets its capitals."""
     parts = [clause.rstrip(".") for clause in clauses if clause]
-    text = ". ".join(c[:1].upper() + c[1:] for c in parts)
+    text = ". ".join(_sentence_case(c) for c in parts)
     return f"{text}." if text else ""
 
 
 def _sentences_pieces(clauses: list) -> list:
-    """`_sentences` as pieces (F fix 7, W7-2): a clause is a string or the `TitleParts` of a
-    finding title that names a path. With no `TitleParts` the result is the one string
-    `_sentences` returns (or no piece for no text). With one, the template is capitalized and
-    stripped of a final period like any clause, and the pieces are the strings around it (merged)
-    and the `TitleParts` themselves, so `_render_pieces` can render the path once and never scan
-    the tool's own words."""
-    if not any(isinstance(clause, TitleParts) for clause in clauses):
-        text = _sentences(clauses)
-        return [text] if text else []
+    """`_sentences` as pieces (F fix 7, W7-2; 0.3.6): one piece per clause, with the ". "
+    between clauses and the final "." as plain strings. A string clause is a `_Clause`, which a
+    sink renders first and capitalizes after (`_render_pieces`), so a name at its start is
+    substituted as written. The `TitleParts` of a finding title that names a path has its
+    template capitalized and stripped of a final period here, since those words are the tool's
+    own, and `_render_pieces` renders the path once and never scans them. No text, no piece."""
     parts: list = []
     for clause in clauses:
         if not clause:
@@ -1849,35 +1891,39 @@ def _sentences_pieces(clauses: list) -> list:
         if isinstance(clause, TitleParts):
             head, placeholder, tail = clause.template.partition("{path}")
             template = head + placeholder + tail.rstrip(".")
-            parts.append(TitleParts(template[:1].upper() + template[1:], clause.path))
+            parts.append(TitleParts(_sentence_case(template), clause.path))
         else:
-            text = clause.rstrip(".")
-            parts.append(text[:1].upper() + text[1:])
+            parts.append(_Clause(clause.rstrip(".")))
+    if all(isinstance(part, _Clause) and not part for part in parts):
+        return []
     pieces: list = []
     for index, part in enumerate(parts):
-        for piece in ((". ",) if index else ()) + (part,):
-            if isinstance(piece, str) and pieces and isinstance(pieces[-1], str):
-                pieces[-1] += piece
-            else:
-                pieces.append(piece)
-    if pieces and isinstance(pieces[-1], str):
-        pieces[-1] += "."
-    else:
-        pieces.append(".")
+        if index:
+            pieces.append(". ")
+        pieces.append(part)
+    pieces.append(".")
     return pieces
 
 
 def _pieces_raw(pieces: list) -> str:
-    """The pieces with the real path (the raw text of a story)."""
-    return "".join(piece.raw() if isinstance(piece, TitleParts) else piece for piece in pieces)
+    """The pieces with the real path and real names (the raw text of a story)."""
+    return "".join(
+        piece.raw() if isinstance(piece, TitleParts)
+        else _sentence_case(piece) if isinstance(piece, _Clause)
+        else piece
+        for piece in pieces
+    )
 
 
 def _render_pieces(pieces: list, redactor: Redactor) -> str:
-    """The pieces as a sink prints them: a string through `Redactor.title` (labels, paths and the
-    rest of the scanner), a `TitleParts` through `Redactor.title_parts` (its path rendered once,
-    its words never scanned)."""
+    """The pieces as a sink prints them: a `_Clause` through `Redactor.title` (labels, paths and
+    the rest of the scanner) and only then capitalized, a `TitleParts` through
+    `Redactor.title_parts` (its path rendered once, its words never scanned), and the separators
+    as they are."""
     return "".join(
-        redactor.title_parts(piece) if isinstance(piece, TitleParts) else redactor.title(piece)
+        redactor.title_parts(piece) if isinstance(piece, TitleParts)
+        else _sentence_case(redactor.title(piece)) if isinstance(piece, _Clause)
+        else piece
         for piece in pieces
     )
 
@@ -1933,7 +1979,7 @@ def _story_records(run: Run, findings: list[Finding], verbose: bool) -> list[dic
     run_relevant = [f for f in run_level if verbose or f.severity != "info"]
     if run_relevant:
         rank = min(_SEVERITIES.index(f.severity) for f in run_relevant)
-        pieces = _sentences_pieces([f.title_parts or f.title for f in run_relevant])
+        pieces = _sentences_pieces([_title_clause(f, None) for f in run_relevant])
         entries.append({
             "agent": "run",
             "severity": _SEVERITIES[rank],

{agent_postmortem-0.3.5 → agent_postmortem-0.3.6}/tests/synthetic-ids.txt

@@ -545,3 +545,4 @@ wf_00000000-8c0
 wf_00000000-cab
 wf_00000000-cac
 wf_00000000-cad
+wf_00000000-b36

{agent_postmortem-0.3.5 → agent_postmortem-0.3.6}/tests/test_n9_docs.py

@@ -96,11 +96,11 @@ def test_changelog_unreleased_entry_is_first_and_grouped():
     assert "http" not in entry
 
 
-def test_the_package_version_is_0_3_5():
+def test_the_package_version_is_0_3_6():
     pyproject = (REPO_ROOT / "pyproject.toml").read_text(encoding="utf-8")
     init = (REPO_ROOT / "src" / "agent_postmortem" / "__init__.py").read_text(encoding="utf-8")
-    assert re.search(r'^version = "0\.3\.5"', pyproject, re.M)
-    assert '__version__ = "0.3.5"' in init
+    assert re.search(r'^version = "0\.3\.6"', pyproject, re.M)
+    assert '__version__ = "0.3.6"' in init
 
 
 # ---- DESIGN ----

{agent_postmortem-0.3.5 → agent_postmortem-0.3.6}/tests/test_plugin.py

@@ -110,17 +110,17 @@ def test_plugin_version_equals_package_version():
     assert plugin["version"] == package_version
 
 
-def test_pyproject_plugin_and_package_versions_are_all_0_3_5():
+def test_pyproject_plugin_and_package_versions_are_all_0_3_6():
     """docs/DESIGN.md 7.1's D1: the literal, not just mutual equality --
     a version bump that only kept two of the three in sync would still
     pass a pure-equality check."""
     pyproject = tomllib.loads((REPO_ROOT / "pyproject.toml").read_text(encoding="utf-8"))
-    assert pyproject["project"]["version"] == "0.3.5"
+    assert pyproject["project"]["version"] == "0.3.6"
     plugin = _load_json(PLUGIN_ROOT / ".claude-plugin" / "plugin.json")
-    assert plugin["version"] == "0.3.5"
+    assert plugin["version"] == "0.3.6"
     import agent_postmortem
 
-    assert agent_postmortem.__version__ == "0.3.5"
+    assert agent_postmortem.__version__ == "0.3.6"
 
 
 def test_pyproject_declares_agent_postmortem_as_primary_and_postmortem_as_alias():

agent_postmortem-0.3.6/tests/test_share_label_case.py

@@ -0,0 +1,284 @@
+"""A user-authored name that starts with a lowercase letter must not reach share output
+capitalized (docs/DESIGN.md 1 and 5.1: pseudonyms for every user-authored name in every
+output; 4.13.5 share invariant).
+
+A story sentence starts with a capital. When its first clause is a finding title that starts
+with the agent's label (`mislabeled_kill`: "<label> interrupted after Ns of silence ..."), 0.3.5
+capitalized the label before the case-sensitive name substitution ran, so "impl:x" printed as
+"Impl:x". From 0.3.6 a story clause is capitalized after the sink substituted names
+(`report._render_pieces`), so the tool's own capitalized words never meet a name either. The
+planted names here start lowercase, unlike the sentinels of test_field_v03_more.py, and every
+check is case-insensitive.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import os
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+import pytest
+
+from agent_postmortem import cli, reader, report
+from agent_postmortem.disclosure import DisclosureContext
+from agent_postmortem.redact import Redactor
+from tests.test_field_v03 import (
+    FAKE_SLUG,
+    FAKE_UUID,
+    _assistant_tool,
+    _kill,
+    _no_config,
+    _parent_path,
+    _tool_result,
+    _user,
+    _wf_dir,
+    _write_jsonl,
+)
+
+_LABEL = "zz-lower-agent-nickname"
+_PHASE = "zz-lower-phase-title"
+_WF_ID = "wf_00000000-b36"
+_AGENT = "ab36" + "0" * 12 + "1"
+
+
+def _backdate(paths: list[Path], when: datetime) -> None:
+    for path in paths:
+        os.utime(path, (when.timestamp(), when.timestamp()))
+
+
+def _killed_after_silence(agent_id: str, base: datetime) -> list[dict]:
+    """One Bash call, then 400 s of silence and the interrupt marker: an unattributed
+    long-silence mislabeled_kill, whose title starts with the label and is the agent's
+    whole story (no path, no commit, no restart)."""
+    return [
+        _user("Investigate.", base, agent_id),
+        _assistant_tool("t1", "Bash", {"command": "ls"}, base + timedelta(seconds=1), agent_id),
+        _tool_result("t1", "ok", base + timedelta(seconds=2), agent_id),
+        _kill(base + timedelta(seconds=402), agent_id),
+    ]
+
+
+def _workflow(tmp_path: Path) -> tuple[Path, Path, Path]:
+    root = tmp_path / "root"
+    run_dir = _wf_dir(root, _WF_ID)
+    base = datetime.now(timezone.utc) - timedelta(days=1)
+    _write_jsonl(run_dir / "journal.jsonl", [
+        {"type": "started", "key": "v2:x", "agentId": _AGENT, "label": _LABEL, "phase": _PHASE},
+    ])
+    transcript = run_dir / f"agent-{_AGENT}.jsonl"
+    _write_jsonl(transcript, _killed_after_silence(_AGENT, base))
+    main = _parent_path(root)
+    _write_jsonl(main, [{
+        "type": "user", "message": {"role": "user", "content": "start"},
+        "sessionId": FAKE_UUID, "timestamp": base.strftime("%Y-%m-%dT%H:%M:%SZ"),
+    }])
+    _backdate([run_dir / "journal.jsonl", transcript, main], base + timedelta(seconds=403))
+    return root, run_dir, main
+
+
+def _session(tmp_path: Path) -> tuple[Path, Path, Path]:
+    root = tmp_path / "root"
+    main = root / FAKE_SLUG / f"{FAKE_UUID}.jsonl"
+    base = datetime.now(timezone.utc) - timedelta(days=1)
+    _write_jsonl(main, [{
+        "type": "user", "message": {"role": "user", "content": "start"},
+        "sessionId": FAKE_UUID, "timestamp": base.strftime("%Y-%m-%dT%H:%M:%SZ"),
+    }])
+    subagents = root / FAKE_SLUG / FAKE_UUID / "subagents"
+    transcript = subagents / f"agent-{_AGENT}.jsonl"
+    _write_jsonl(transcript, _killed_after_silence(_AGENT, base))
+    meta = subagents / f"agent-{_AGENT}.meta.json"
+    meta.write_text(json.dumps({"agentType": "general-purpose", "description": _LABEL}),
+                    encoding="utf-8")
+    _backdate([main, transcript, meta], base + timedelta(seconds=403))
+    return root, main, main
+
+
+_KINDS = {"workflow": _workflow, "session": _session}
+
+
+def _outputs(capsys, monkeypatch, tmp_path, root: Path, run: Path, main: Path) -> dict[str, str]:
+    """Every share sink that can carry a label, by command."""
+    # (argv, expected exit code): run and scan succeed; rescue exits 4 for a run whose risk
+    # population it cannot complete (docs/DESIGN.md 4.11)
+    commands = {
+        "run": (["run", str(run)], 0),
+        "run --json": (["run", str(run), "--json"], 0),
+        "run --verbose": (["run", str(run), "--verbose"], 0),
+        "run --bug-report": (["run", str(run), "--bug-report"], 0),
+        "scan": (["scan", "--root", str(root)], 0),
+        "scan --all": (["scan", "--root", str(root), "--all"], 0),
+        "scan --json": (["scan", "--root", str(root), "--all", "--json"], 0),
+        "rescue plan": (["rescue", "plan", str(run)], 4),
+        "rescue plan --json": (["rescue", "plan", str(run), "--json"], 4),
+        "rescue status": (["rescue", "status", str(run)], 4),
+    }
+    run_id = reader.load_run(run).run_id
+    out: dict[str, str] = {}
+    for name, (argv, expected) in commands.items():
+        code = cli.main(argv)
+        captured = capsys.readouterr()
+        assert code == expected and captured.out.strip(), (name, code, captured.err)
+        if name.endswith("--json"):
+            json.loads(captured.out)
+        record = {"rescue plan": "UNIT agent-1", "rescue plan --json": '"agent-1"',
+                  "rescue status": None}.get(name, run_id)
+        if record is not None:
+            assert record in captured.out, (name, record)
+        out[name] = captured.out + captured.err
+    monkeypatch.setenv("XDG_STATE_HOME", str(tmp_path / "hookstate"))
+    payload = {"hook_event_name": "Stop", "transcript_path": str(main),
+               "session_id": FAKE_UUID, "stop_hook_active": False}
+    monkeypatch.setattr("sys.stdin", io.StringIO(json.dumps(payload)))
+    assert cli.main(["hook", "check"]) == 0
+    captured = capsys.readouterr()
+    out["hook check"] = captured.out + captured.err
+    return out
+
+
+@pytest.mark.parametrize("kind", sorted(_KINDS))
+def test_a_lowercase_label_never_reaches_share_output_in_any_case(
+    kind, tmp_path, monkeypatch, capsys,
+):
+    _no_config(monkeypatch, tmp_path)
+    root, run, main = _KINDS[kind](tmp_path)
+    outputs = _outputs(capsys, monkeypatch, tmp_path, root, run, main)
+    # the planted case is exercised: the story that used to carry the label is there, aliased
+    assert "Agent-1 interrupted after 400s" in outputs["run"]
+    stories = [entry["text"] for entry in json.loads(outputs["run --json"])["stories"]]
+    assert any(text.startswith("Agent-1 interrupted after 400s") for text in stories), stories
+    leaks = {
+        name: text for name, text in outputs.items()
+        if _LABEL in text.lower() or _PHASE in text.lower()
+    }
+    assert not leaks, {name: [line for line in text.splitlines()
+                              if _LABEL in line.lower() or _PHASE in line.lower()]
+                       for name, text in leaks.items()}
+
+
+@pytest.mark.parametrize("kind", sorted(_KINDS))
+def test_the_story_still_starts_with_a_capital_after_the_label_is_replaced(
+    kind, tmp_path, monkeypatch, capsys,
+):
+    _no_config(monkeypatch, tmp_path)
+    _root, run, _main = _KINDS[kind](tmp_path)
+    cli.main(["run", str(run)])
+    out = capsys.readouterr().out
+    story = [line for line in out.splitlines() if "interrupted after 400s" in line]
+    assert len(story) == 1, out
+    sentence = story[0].strip().split("  ", 1)[1]
+    assert sentence.startswith("Agent-1 interrupted after 400s"), story[0]
+
+
+def test_local_still_prints_the_real_label_capitalized_where_the_sentence_starts(
+    tmp_path, monkeypatch, capsys,
+):
+    _no_config(monkeypatch, tmp_path)
+    _root, run, _main = _workflow(tmp_path)
+    cli.main(["run", str(run), "--local"])
+    out = capsys.readouterr().out
+    assert "Zz-lower-agent-nickname interrupted after 400s" in out
+
+
+def _share_redactor(**names: str) -> Redactor:
+    redactor = Redactor(context=DisclosureContext(level="share", home="/home/user"))
+    registry = redactor.fresh_names(detailed=False)
+    for category, value in names.items():
+        getattr(registry, category)(value)
+    return redactor
+
+
+def _story(redactor: Redactor, *clauses) -> str:
+    return report._render_pieces(report._sentences_pieces(list(clauses)), redactor)
+
+
+def test_a_clause_that_starts_with_a_lowercase_label_is_aliased_then_capitalized():
+    redactor = _share_redactor(agent="zz-lower")
+    assert _story(redactor, "zz-lower interrupted after 400s", "Wrote no paths.") == (
+        "Agent-1 interrupted after 400s. Wrote no paths."
+    )
+
+
+def _demo_copy(tmp_path, label: str) -> Path:
+    """The packaged demo workflow (two agents, each killed once by the runtime and restarted),
+    with every journal label replaced by `label`."""
+    import shutil
+    from importlib import resources
+    source = resources.files("agent_postmortem") / "demo" / "-home-user-project"
+    target = tmp_path / "root" / "-home-user-project"
+    with resources.as_file(source) as path:
+        shutil.copytree(path, target)
+    run_dir = next(target.glob("*/subagents/workflows/wf_*"))
+    journal = run_dir / "journal.jsonl"
+    rows = [json.loads(line) for line in journal.read_text(encoding="utf-8").splitlines()]
+    for row in rows:
+        if "label" in row:
+            row["label"] = label
+    journal.write_text("".join(json.dumps(row) + "\n" for row in rows), encoding="utf-8")
+    return run_dir
+
+
+def test_a_label_that_is_the_first_word_of_the_tools_own_clause_leaves_it_alone(
+    tmp_path, monkeypatch, capsys,
+):
+    # Review round 2: a workflow agent labelled `killed` with a runtime retry. 0.3.5 printed
+    # "Killed 1 time by the runtime (416s of silence)." and so must 0.3.6, in text and JSON.
+    _no_config(monkeypatch, tmp_path)
+    run_dir = _demo_copy(tmp_path, "killed")
+    assert cli.main(["run", str(run_dir)]) == 0
+    text = capsys.readouterr().out
+    assert "Killed 1 time by the runtime (416s of silence)." in text, text
+    assert cli.main(["run", str(run_dir), "--json"]) == 0
+    stories = [entry["text"] for entry in json.loads(capsys.readouterr().out)["stories"]]
+    assert stories and all(
+        story.startswith("Killed 1 time by the runtime") for story in stories
+    ), stories
+
+
+@pytest.mark.parametrize(("label", "clause"), [
+    ("restarted", "restarted 1 time"),
+    ("attempt", "attempt 2 failed: usage limit"),
+    ("stopped", "stopped by the parent"),
+])
+def test_the_tools_own_lowercase_clause_words_are_capitalized_before_any_name_meets_them(
+    label, clause,
+):
+    shown = _story(_share_redactor(agent=label), report._own_clause(clause))
+    assert shown == clause[:1].upper() + clause[1:] + ".", shown
+
+
+@pytest.mark.parametrize(("category", "name", "clause"), [
+    ("agent", "wrote", "Wrote no paths."),
+    ("type", "codex", "1 Codex call could not start"),
+    ("agent", "killed", "Killed 1 time by the runtime (400s of silence)"),
+])
+def test_the_tools_own_capitalized_words_never_meet_a_name_of_another_case(
+    category, name, clause,
+):
+    # A label or agent type that is a plain word only matches that word as written; the
+    # tool's own capitalized words around it stay as they are (no sentence-case matching).
+    assert _story(_share_redactor(**{category: name}), clause) == clause.rstrip(".") + "."
+
+
+def test_a_run_title_in_the_tools_own_words_keeps_its_capital_whatever_the_labels(
+    tmp_path, monkeypatch, capsys,
+):
+    # Review round 3: a run-level story is a list of finding titles in the tool's own words; a
+    # label that is their first word (here "the") must not rewrite them. 0.3.5 printed
+    # "The harness reported this workflow failed." and so must 0.3.6.
+    from tests.test_field_v03 import _case5_fixture
+    run_dir, _parent = _case5_fixture(tmp_path, monkeypatch)
+    journal = run_dir / "journal.jsonl"
+    rows = [json.loads(line) for line in journal.read_text(encoding="utf-8").splitlines()]
+    for row in rows:
+        if "label" in row:
+            row["label"] = "the"
+    journal.write_text("".join(json.dumps(row) + "\n" for row in rows), encoding="utf-8")
+    assert cli.main(["run", str(run_dir)]) == 3  # a FAILED verdict
+    text = capsys.readouterr().out
+    assert "The harness reported this workflow failed." in text, text
+    assert cli.main(["run", str(run_dir), "--json"]) == 3
+    stories = [entry["text"] for entry in json.loads(capsys.readouterr().out)["stories"]]
+    assert "The harness reported this workflow failed." in stories, stories

{agent_postmortem-0.3.5 → agent_postmortem-0.3.6}/uv.lock

@@ -4,7 +4,7 @@ requires-python = ">=3.11"
 
 [[package]]
 name = "agent-postmortem"
-version = "0.3.5"
+version = "0.3.6"
 source = { editable = "." }
 
 [package.optional-dependencies]