@jesdi/skills 0.0.48 → 0.0.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jesdi/skills",
-  "version": "0.0.48",
+  "version": "0.0.50",
   "description": "jesdi's agent skills (content package consumed by @jesdi/skills-cli)",
   "license": "MIT",
   "repository": {

package/skills/implement-spec/driver_agents.py

@@ -117,14 +117,32 @@ def command(role: str, entry: str, report: str) -> list[str]:
     """The CLI call for one agent; the prompt goes to its stdin."""
     provider, model, effort = split(entry)
     if provider == "openai":
-        # No --ephemeral: the rollout on disk is the trace. A read-only agent cannot write its report, so -o saves it.
-        tail = ["--sandbox", "read-only", "-o", report] if role in READ_ONLY else ["--sandbox", "workspace-write"]
+        # No --ephemeral: the rollout on disk is the trace. A read-only agent may not write its report, so -o saves
+        # the last message next to it; settle_report picks one. -o on the report itself overwrites a written report.
+        tail = ["--sandbox", "read-only", "-o", last_message(report)] if role in READ_ONLY else [
+            "--sandbox", "workspace-write"]
         return ["codex", "exec", "--model", model, "-c", f'model_reasoning_effort="{effort}"', *tail]
     # stream-json keeps tool output in the log and ends with a result that has total_cost_usd.
     return ["claude", "-p", "--model", model, "--effort", effort, "--permission-mode", "auto",
             "--output-format", "stream-json", "--verbose"]
 
 
+def last_message(report: str | Path) -> str:
+    """The file where codex saves the last message of a read-only agent."""
+    return f"{report}.last"
+
+
+def settle_report(report: Path) -> None:
+    """The report is the one the agent wrote when it parses, else the saved last message, when there is one."""
+    last = Path(last_message(report))
+    if not last.exists():
+        return
+    with contextlib.suppress(OSError, ValueError):
+        json.loads(report.read_text())
+        return
+    report.write_text(last.read_text())
+
+
 def render(name: str, values: dict[str, str]) -> str:
     return re.sub(r"\{([a-z_]+)\}", lambda m: values[m.group(1)], (SKILL / "prompts" / f"{name}.md").read_text())
 

package/skills/implement-spec/driver_report.py

@@ -27,9 +27,16 @@ def _git(repo: str, *args: str, end: str = "\n") -> list[str]:
     return [line for line in out.split(end) if line]
 
 
+def _squash(text: str) -> str:
+    """Each run of whitespace other than a line break as one space."""
+    return re.sub(r"[^\S\n]+", " ", text)
+
+
 def _seen(line: str, log: str) -> bool:
-    # A stream-json log holds tool output as JSON strings, so the escaped form of the line counts too.
-    return line in log or json.dumps(line)[1:-1] in log
+    # A stream-json log holds tool output as JSON strings, so the escaped forms of the line count too: json.dumps
+    # escapes non-ASCII, the claude log keeps it raw. Spacing does not count: pytest pads some lines.
+    line, log = _squash(line.strip()), _squash(log)
+    return any(form in log for form in (line, json.dumps(line)[1:-1], json.dumps(line, ensure_ascii=False)[1:-1]))
 
 
 def _shas(report: dict) -> list[str]:
@@ -89,10 +96,11 @@ def _merged_errors(report: dict, context: dict) -> list[str]:
 
 def _proof_errors(report: dict, context: dict) -> list[str]:
     """Every claimed red line (a test-writer `red`, a reviewer `mutations`) is in the agent's log."""
-    lines = [r["line"] for r in report.get("red", [])] + [m["red"] for m in report.get("mutations", [])]
-    errors = []
-    if lines and not all(_seen(line, Path(context["log"]).read_text(errors="replace")) for line in lines):
-        errors.append(RED)
+    lines = ([(r["test"], r["line"]) for r in report.get("red", [])]
+             + [(m["test"], m["red"]) for m in report.get("mutations", [])])
+    log = Path(context["log"]).read_text(errors="replace") if lines else ""
+    errors = [f"{RED}: {test}: {line if len(line) <= 200 else line[:197] + '...'}"
+              for test, line in lines if not _seen(line, log)]
     if context.get("full") and "findings" in report and "mutations" not in report:
         errors.append("mutations: required in a full review")
     return errors

package/skills/implement-spec/driver_run.py

@@ -291,9 +291,11 @@ def _attempts(run: Run, role: str, number: str, slot: str, values: dict[str, str
     for _ in range(2):
         prompt.write_text(text)
         report.unlink(missing_ok=True)
+        Path(driver_agents.last_message(report)).unlink(missing_ok=True)
         start = time.monotonic()
         code = driver_agents.launch(argv, prompt, log, minutes * 60, slot)
         seconds = time.monotonic() - start
+        driver_agents.settle_report(report)
         error, rerun_lines = _rejection(role, code, minutes, report, context, alone, detached)
         _record_attempt(run, role, number, entry, seconds, log, error)
         if not error:

package/skills/implement-spec/tests/test_agents.py

@@ -211,6 +211,29 @@ def test_reviewing_roles_launch_codex_exec_read_only(env, role):
     assert value_after(argv, "--model", "-m") == "gpt-sol"
 
 
+@pytest.mark.parametrize("writes", ["file", "message"])
+def test_a_read_only_codex_report_is_the_file_it_wrote_else_its_last_message(env, writes):
+    # A read-only sandbox can still let the agent write its report; codex then writes the last message to the -o file.
+    w = World(env, refactor=True, correctness=["openai/gpt-sol@medium"])
+    report = {"status": "DONE", "commits": [], "files": [], "concerns": [], "findings": []}
+    (w.tmp / "bin/codex").write_text(f"""#!{sys.executable}
+import re, sys
+from pathlib import Path
+prompt, argv = sys.stdin.read(), sys.argv[1:]
+last = Path(argv[argv.index("-o") + 1])
+if "implement-spec preflight" in prompt:
+    last.write_text("OK")
+elif {writes!r} == "file":
+    Path(re.search(r"JSON report at (\\S+?)\\.? ", prompt).group(1)).write_text({json.dumps(report)!r})
+    last.write_text("Wrote and validated the report.\\n")
+else:
+    last.write_text({json.dumps(report)!r})
+""")
+    ok(w.run(None, "--only", "correctness", runner=False))
+    assert json.loads((w.repo / ".agent/implement/01/correctness-0.json").read_text()) == report
+    assert "correctness ran on openai/gpt-sol@medium" in w.ledger() and "report accepted" in w.ledger()
+
+
 @pytest.mark.parametrize("entry", ["claude-opus-5@medium", "anthropic/claude-opus-5@medium"])
 def test_claude_entry_launches_claude_p_and_bare_means_anthropic(env, entry):
     w = World(env, refactor=True, implementer=[entry])
@@ -324,6 +347,7 @@ def test_red_line_missing_from_the_log_reruns_once_then_blocks(env, second_match
     proc = w.run(plan)
     second = w.calls("test-writer")[1]["prompt"]
     assert "red line not found in log" in second and "red line not found" not in w.calls("test-writer")[0]["prompt"]
+    assert f"red line not found in log: tests/test_export.py::test_rows: {RED}" in second
     if second_matches:
         ok(proc)
         assert len(w.calls("implementer")) == 1
@@ -333,6 +357,17 @@ def test_red_line_missing_from_the_log_reruns_once_then_blocks(env, second_match
         assert any("01" in l and "BLOCKED" in l for l in w.ledger().splitlines()), w.ledger()
 
 
+@pytest.mark.parametrize("claimed, printed", [
+    ("E       assert 0 == 'rows'", "E           assert 0 == 'rows'"),  # pytest pads a parametrized test's lines
+    ("AssertionError: '12 UNP\u2212 EL' !~ /Resilience\\s*4\\.3/",  # a stream-json log keeps non-ASCII raw
+     '"text": "AssertionError: \'12 UNP\u2212 EL\' !~ /Resilience\\\\s*4\\\\.3/"')], ids=["spacing", "non-ascii"])
+def test_red_line_that_differs_from_the_log_only_in_spacing_or_escaping_is_seen(env, claimed, printed):
+    w = World(env)
+    writer = with_report(tw(0, printed + "\n"), red=[{"test": "tests/test_export.py::test_rows", "line": claimed}])
+    ok(w.run({"test-writer": [writer], "implementer": [impl()]}))
+    assert len(w.calls("test-writer")) == 1
+
+
 def test_implementer_report_with_no_new_commit_is_a_violation(env):
     w = World(env)
     nothing = with_report(impl(), commits=[])

package/skills/implement-spec/tests/test_driver.py

@@ -342,7 +342,7 @@ def test_command_lines_per_provider():
     assert driver_agents.command("implementer", "openai/gpt-sol@high", "r.json") == [
         "codex", "exec", "--model", "gpt-sol", "-c", 'model_reasoning_effort="high"', "--sandbox", "workspace-write"]
     assert driver_agents.command("reviewer", "openai/gpt-sol@high", "r.json")[-4:] == [
-        "--sandbox", "read-only", "-o", "r.json"]
+        "--sandbox", "read-only", "-o", "r.json.last"]
     assert driver_agents.command("reviewer", "opus@low", "r.json")[:6] == [
         "claude", "-p", "--model", "opus", "--effort", "low"]
 

package/skills/implement-spec/tests/test_report.py

@@ -146,7 +146,8 @@ def test_red_line_absent_from_the_log_is_a_violation(world):
     shas, check, _ = world
     assert check("test-writer", writer(shas), start=shas["base"]) == []
     report = writer(shas, red=[{"test": "t", "line": "FAILED tests/test_export.py::test_rows - KeyError"}])
-    assert "red line not found in log" in check("test-writer", report, start=shas["base"])
+    assert check("test-writer", report, start=shas["base"]) == [
+        "red line not found in log: t: FAILED tests/test_export.py::test_rows - KeyError"]
 
 
 def test_reviewer_fields_and_mutation_proofs(world):

package/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-17T23:11:17.693Z",
+  "generatedAt": "2026-10-19T09:42:49.911Z",
   "skills": [
     {
       "name": "backlog",
@@ -46,8 +46,8 @@
     },
     {
       "name": "implement-spec",
-      "version": "0.1.24",
-      "hash": "sha256-8df47be43b54ab8ced155594ab3dfa0c23a27960597774d7868ca4e444ab817a",
+      "version": "0.1.26",
+      "hash": "sha256-40637f9172d94edb3ef009f91f58e27f7cd400ed15935c5a62654822a57208c5",
       "description": "Implement a specification in code."
     },
     {