@jesdi/skills 0.0.49 → 0.0.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jesdi/skills",
-  "version": "0.0.49",
+  "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_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])

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-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-18T20:38:07.695Z",
+  "generatedAt": "2026-10-19T09:42:49.911Z",
   "skills": [
     {
       "name": "backlog",
@@ -46,8 +46,8 @@
     },
     {
       "name": "implement-spec",
-      "version": "0.1.25",
-      "hash": "sha256-644814949264c14d8ce10419e2b71af1c6f00e872c328ff31e47b4441eac5365",
+      "version": "0.1.26",
+      "hash": "sha256-40637f9172d94edb3ef009f91f58e27f7cd400ed15935c5a62654822a57208c5",
       "description": "Implement a specification in code."
     },
     {