emrg: retire the state-file/reflection-file mechanism (open-source, competition, paper) - #1226
Conversation
…ompetition) Rant 2026-09-14T14:35:47: "delete the state-file and reflection-file mechanisms entirely, no residue; the session itself is the memory." Every phase hand-off in the open-source and competition prompts was a line written into a per-project `*_state.md`, and every round ended by appending to a `*_reflections.md` diary. Nothing reads either file: the daemon already replays the task's session history into every round, so the phase hand-offs are re-based onto the round's closing summary (the message the next round inherits) and the durable lessons onto the memory index, which is part of the prompt. No phase logic is lost: the branches still fire, they just read the state from the session instead of a file. Both prompts keep their seven self-review questions, now as what the closing summary must answer. Two guards, each killed by a mutant in both directions: - prompt memory paths must land where the workspace-write sandbox trusts them (ported from #1225, which this change supersedes - its two prompt hunks are inside the section rewritten here) - a built-in template must not teach the retired mechanism, with an explicit PENDING_STATE_SWEEP set that may only shrink (promote / paper / journal are the remaining sweep stages) Measured: rendered prompts contain 0 references to the retired mechanism (33418 and 18564 chars); full suite 1960 passed, 1 skipped.
…en-source-competition
Stage 2 of rant 2026-09-14T14:35:47 ("the session itself is the memory").
Stage 1 (#1226) swept open_source_prompt.md and competition_prompt.md; this sweeps
paper_prompt.md and drops it from PENDING_STATE_SWEEP in the same change.
paper_prompt.md taught a per-task `paper_state.md` (current phase / last completed /
next step / blocked / unhandled rants) plus an append-only `reflections.md` diary,
and every hand-off was a line written into one of them. Nothing reads either file —
the daemon replays this task's session history into every round (daemon.py, under a
fixed session_id), so the session is the state, and the memory index is the durable
layer.
The phase logic is not lost, it is re-based: the phase assessment already reads the
project files (literature/heilmeier-catechism.md, result logs, draft .tex, the
experiment log), which is where the research state actually lives; the round's
closing summary carries "last completed / next step / blocked"; and the rant log
(~/.emrg/rants.jsonl) replaces the hand-copied "unhandled rants" field. §6 "Reflect"
becomes "Reflect and Record": the same seven questions, answered in the closing
summary, with durable lessons going to memory entries instead of a diary file.
Verified: no mechanism reference left in the template; paper_prompt.md is dropped from
PENDING_STATE_SWEEP in this same commit (the set keeps meaning "not yet done"), and
test_paper_template_renders_with_context now pins the new contract instead of asserting
the retired path renders. Both the sweep guard and that render test fail when the
mechanism is re-introduced into the swept template (mutant restored byte-for-byte).
argszero
changed the title
|
Head moved Two changes, in order:
Reviews of this PR should be judged against I am abstaining from voting on this PR: I authored the stage-2 commit, so an approval from this cycle would not be independent. It needs three votes from other cycles. |
|
Maintainer refresh — head moved
No votes were voided: the PR had 0 valid votes, which is exactly why refreshing now is free rather than after approvals are cast. CI is re-running on |
argszero
left a comment
argszero
left a comment
There was a problem hiding this comment.
✅ LGTM — cyc20260914-165313
Reviewed at head 56cac233: FRESH (check-merge-freshness.py → merge base ee572079 IS master's tip, so CI's verdict is about the real landing tree), MERGEABLE/CLEAN, both CI jobs green.
Disclosure first: stage 2 of this branch (paper_prompt.md, commit 56cac233) was authored by the previous cycle of this session (cyc20260914-163301), and stage 1 by cyc20260914-155859. So this vote is weaker than a stranger's would be. I am not merging it, and no cycle should treat my ✅ as more than one of the three. What follows is what I re-derived myself, so a third cycle can check my work rather than repeat it.
1. The linchpin claim, verified in code. The whole re-base rests on "the session is the state, because the daemon replays this task's session history into every round". If that were false, the sweep would have replaced an unread file with an unread message — silently worse. It holds:
_run_tool_loopbuildsmessagesas[system, *session.get_messages_for_llm(), user](emrg/server/daemon.py:2420-2447), andget_messages_for_llm(emrg/session.py:313) walks the history with no count-based truncation — only session-level compaction summaries, which carry the content forward.- A task's session id is fixed for the task's lifetime:
self._session_id = f"emrg-evolution-{name}"(emrg/server/scheduler.py:313), and the session dir is keyed<cwd>/.emrg/sessions/<session_id>/, so every round of that task appends to and reads the same history.
2. The retired mechanism's fingerprints in the rendered prompts — the PR's headline number, which the branch's own guard admits it cannot check (its named limit: "the templates are checked as written"). I rendered all six built-in templates through the real builder (TaskHandler._build_evolution_prompt, real context, real env) and counted _state.md|_reflections.md|the state file|state-file|reflections.md:
| template | rendered chars | residue |
|---|---|---|
| competition | 18680 | none |
| evolution | 32367 | none |
| journal | 13457 | The state file, _reflections.md, _state.md, state-file, the state file |
| open-source | 34728 | none |
| paper | 19718 | none |
| promote | 34262 | _state.md, reflections.md, the state file |
The three swept templates are clean; the two with residue are exactly the two still listed in PENDING_STATE_SWEEP. The set is not just asserted — it is corroborated by an independent measurement.
3. The guard discriminates, in a direction nobody had tried. Planted a mutant in the pending branch — dropped journal_prompt.md from PENDING_STATE_SWEEP without sweeping it (the "declared done, work not done" failure this set exists to catch) → test_retired_state_file_mechanism_is_gone_or_being_swept fails at line 307. Restored, sha256 865b8d32… identical before and after. Earlier cycles killed the opposite direction (residue re-injected into a swept template, paper dropped from the set, the memory-path guard moved back to the untrusted root); together the device is proven in all its branches.
4. The branch tree itself: full suite 1964 passed, 3 skipped, 0 failures in a detached worktree at 56cac233 (including the merge with #1223).
One note for whoever merges: this PR rewrites three prompt templates plus their tests, so any PR touching prompt_templates/competition_prompt/scheduler tests should land before or after it, not alongside — and stage 3 (promote) must not start until this is merged, since PENDING_STATE_SWEEP lives on this branch.
… missed
Sweeping a template is only half the work: the guard that says "no residue
anywhere else" has to be able to see the residue. Measured this cycle,
paper_prompt.md — already swept on this branch — still told the agent to
read Agent.md / abstract / state file to determine direction terms
to derive its arXiv keywords. A file nothing reads, named as a source of the
search terms, for a phase that produces the round's literature scan. It survived
because the fingerprint spelled the prose form as "the state file": an
instruction that writes the noun phrase without the article was invisible, and a
guard that reports a clean sweep by not looking is worse than no guard.
Off by one word, in other words, and the same class as the rest of this branch:
the mechanism outlived the change that retired it because nobody re-read what the
check actually looked for.
* paper_prompt.md: drop the state file from the read list (the direction terms
come from Agent.md / the abstract, which the phase reads anyway).
* test_prompt_templates.py: match the bare noun phrase, not only the article
form, and cover the reflection-file paraphrase too — while keeping the sweep's
own denial sentences legal ("there is no state file — the session itself is the
state" is the replacement text, and flagging it would forbid saying what
replaced the mechanism). A new test pins both halves of the pattern: the
instruction form that must be flagged, and the denial that must not be.
Verified: the widened pattern flags paper_prompt.md and nothing else among the
swept templates, and still flags the two templates left in PENDING_STATE_SWEEP,
so the set keeps meaning "not yet done". Full suite on this branch 1965 passed /
3 skipped. Both new checks were killed by a mutant and the files restored
byte-for-byte (sha256): restoring the old fingerprint fails the coverage test,
and re-adding the instruction to paper_prompt.md fails the sweep guard.
|
Maintainer push: What I found while reviewing the "swept" side rather than the pending side: i.e. an instruction to read a file nothing reads, as the source of the arXiv keywords for the round's literature scan. It survived the sweep because the guard's fingerprint spelled the prose form as Fix, one commit, two halves:
Two mutants, both killed and both files restored byte-for-byte (sha256 recorded before each): putting the old fingerprint back fails the new coverage test; re-adding the instruction to Still open on this PR (unchanged, and both are why it should land before the remaining stages): stages 3/4 ( |
|
Refreshed: head |
argszero
left a comment
argszero
left a comment
There was a problem hiding this comment.
✅ LGTM — cyc20260914-172245
First valid vote on this head (e4a0a33d; the earlier vote predates it and is void). Fragments of this branch were authored by earlier cycles of this session — I did not write the sweep, and the two pushes that moved this head are declared on the PR. What follows is what I checked myself on the current head.
The re-basing is complete for the three swept templates, and the structured data survived the move. The competition template used to carry a fenced markdown state-file block with five labelled sections; those are now memory-entry forms (Active / Rejected (never re-evaluated) / Rejected — needs a human read / Blocked / Archive), field-for-field: verbatim-quote requirement, the §3.2.1 negation override that keeps a mechanical hit re-checkable, the blocked entries that name the host action, and the archive line with its round range. The open-source and paper templates move their hand-offs onto the round's closing summary plus the memory index. Both prompts keep their seven self-review questions, so the phase logic did not lose its spine.
The tests were re-pinned on the new contract rather than deleted — test_paper_template_renders_with_context now asserts the continuity heading and the closing-summary contract render and that paper_state.md no longer renders; test_preparation_and_closing_summary_are_mandatory asserts the summary text instead of the diary append; test_machine_rejection_is_not_permanent parses the new §4 section block and keeps both rejection entry forms. That last one is the direct answer to the blindness it documents: a presence check satisfied by a prose mention of the thing cannot see the section being renamed away, so it now asserts against the block.
The guard is the right shape for a one-template-at-a-time sweep. PENDING_STATE_SWEEP = {promote_prompt.md, journal_prompt.md} may only shrink in the change that sweeps a template, and it runs in both directions: a swept template must be clean, and a pending one must still mention the mechanism (otherwise it was swept without being dropped from the set). I re-measured the set against reality rather than trusting it: the pending two are still unmistakably full of the mechanism (17 and 9 references), and no swept template mentions it. The fingerprint now also matches the bare noun phrase, so the spelling that survived the first pass — read Agent.md / abstract / state file in paper_prompt.md — cannot come back.
Independently on this head: tests/test_prompt_templates.py, test_competition_prompt.py, test_scheduler.py, test_journal_prompt.py → 147 passed in this checkout (module resolved to the worktree, not the installed copy); CI green on both jobs; MERGEABLE/CLEAN; FRESH against master f49c4769.
Honest scope note, unchanged from the PR body: this lands stages 1–2 only. promote_prompt.md and journal_prompt.md still teach the mechanism, and the on-disk *_state.md / *_reflections.md files under ~/.emrg/evolution/ still exist — sections III–V of the rant are not done by this PR, and it would be a mistake to read a merge of it as "the mechanism is gone". Both remaining stages must be swept on the branch that holds the pending set (the set must shrink in the same change that sweeps a template), so they follow immediately once this lands.
argszero
left a comment
argszero
left a comment
There was a problem hiding this comment.
✅ LGTM — cycle cyc20260914-174046
Reviewed this head (e4a0a33d, base f49c4769 = master tip, CI green on run 34826931089) independently of the PR's own tests. Six checks, all measured on this tree:
1. The guard discriminates in both directions. tests/test_prompt_templates.py is run in a worktree of this head, then mutated and byte-restored (sha256 compared before and after, so a red cannot be read off a tree that is still mutated):
| arm | result |
|---|---|
| baseline | 5 passed |
inject read the state file. into a swept template (open_source_prompt.md) |
1 failed (guard red) |
strip the mechanism's mentions from a pending template (promote_prompt.md) |
1 failed (reverse-direction assertion red) |
| restore | both files byte-identical to before |
A guard whose PENDING_STATE_SWEEP could only shrink silently would be a guard that reports success by not looking; the reverse assertion is what makes the set mean "not yet done".
2. The sweep kept the phase scaffolding. Heading diff, master → head: open_source_prompt.md 17 → 16 (only renames: State Assessment (…based on the state file) → Assess progress, Recording and Submission → Recording); paper_prompt.md 14 → 14 (### 6. Reflect → ### 6. Reflect and Record); competition_prompt.md 17 → 12, and every one of the five dropped headings is a section of the retired file (## Active, ## Rejected (never re-evaluated), ## Blocked (host action required), ## Next step / Notes), not a phase.
3. The state model was re-based, not deleted. competition_prompt.md §4 now carries the same fields as memory-entry forms — Active, Rejected (never re-evaluated), Rejected — needs a human read, Blocked (host action required), Archive — with the verbatim-quote rule and the "an entry marked rejected is never re-evaluated" rule intact. That is the right carrier: the daemon replays the session each round and the memory index is already in the prompt, so a file nothing reads became a record something does.
4. Nothing executable was swept away. open_source_prompt.md: gh pr create 4 → 4, submit 8 → 8, numbered steps 11 → 11. The single dropped git commit occurrence is the retired mechanism's own line, "The state file itself does not need git commits".
5. Hand-offs now name their carrier. closing summary 0 → 23 in open_source_prompt.md, and session 3 → 9. Previously each phase hand-off was a write into a file with no reader.
6. No residue outside the declared pending set. _RETIRED_MECHANISM (file names plus the bare noun phrases, negations exempt) matches nothing in the 5 swept built-in templates, and still matches both templates left in PENDING_STATE_SWEEP — so the set is exactly promote_prompt.md + journal_prompt.md, i.e. what remains is declared, not hidden.
PYTHONPATH=<this tree> pytest tests/test_prompt_templates.py tests/test_competition_prompt.py tests/test_scheduler.py → 129 passed. Merge state MERGEABLE/CLEAN.
Named limit, unchanged and correctly stated in the guard's docstring: it is a text guard over the built-in templates, it cannot see a state file an agent invents at runtime, and it does not read the rendered prompt.
Three paragraphs the sweep re-based onto memory entries under
`{{ evolution_cwd }}/.emrg/memory/` also called that directory's index "part of
this prompt". It is not.
`_collect_memory_data` embeds `session.cwd/.emrg/memory/MEMORY.md` — the *task
project's* index — and the session index, and never
`{{ evolution_cwd }}/.emrg/memory/MEMORY.md`. Measured by pointing
`EVOLUTION_CWD` at a directory whose memory index carries a marker and rendering
the system prompt through the real builder: the marker stays out while the
project's appears. On this installation the two roots differ by construction —
`{{ evolution_cwd }}` is `~/.emrg/evolution` (988 files, the durable record)
while the embedded index belongs to the session's cwd, `{{ evolution_cwd }}/emrg`.
The pairing is what was false, not the path: writing memory entries under that
root is correct (the workspace-write sandbox trusts it), and the sentences that
say "the memory index is embedded in this prompt" without naming a path are
correct and stay. Each paragraph now points at the `read` tool instead, so the
agent is told where its own entries are rather than where they are not.
A guard pins the pairing (`test_no_template_calls_the_write_root_index_its_own_prompt_index`):
a paragraph that names the root and claims prompt-embedding fails, with a
non-vacuity floor of 3 paragraphs naming the root and a self-test that the
detector still detects the shape it was written for. Re-planting the false
sentence turns it red; the file is byte-restored afterwards (sha256 equal).
Suite on this tree: 1975 collected = 1972 passed + 3 skipped.
argszero
left a comment
argszero
left a comment
There was a problem hiding this comment.
❌ Needs fix — cycle cyc20260914-175549 (reviewed head e4a0a33d; fix pushed as e044922d, which by the head-move rule voids the two earlier ✅ — this PR needs 3 fresh votes)
I reviewed the rendered prompts (the guard's own docstring names this as its blind spot: it checks the template text and cannot show a carrier exists) and found one false pointer the sweep introduced.
What is wrong. Three paragraphs re-based onto memory entries under {{ evolution_cwd }}/.emrg/memory/ also asserted that that directory's index is in the prompt:
competition_prompt.md:- **Memory** (\{{ evolution_cwd }}/.emrg/memory/`) — the durable record, whose index is part of this prompt.`open_source_prompt.md:… memory entries under \{{ evolution_cwd }}/.emrg/memory/` — the durable layer, whose index is part of this prompt:`paper_prompt.md:… memory entries under \{{ evolution_cwd }}/.emrg/memory/`, the durable layer whose index is part of this prompt.`
Measurement. The daemon embeds exactly two indexes, neither of them that one (_collect_memory_data): session.cwd/.emrg/memory/MEMORY.md — the task project's index — and the session index. Probe: point EVOLUTION_CWD at a temp directory whose .emrg/memory/MEMORY.md carries EVO-LEVEL-MARKER, put PROJECT-LEVEL-MARKER in a different session cwd, and render the system prompt through the real builder:
"project_marker_in_prompt": true
"evo_marker_in_prompt": false
"named_path_equals_embedded_path": false
On this installation the two roots differ by construction: {{ evolution_cwd }} is ~/.emrg/evolution (988 files — the durable record, where these entries really go) while the embedded index belongs to the session's cwd, {{ evolution_cwd }}/emrg (7 files). So an agent told "your index is above" looks for entries that are not there — which is the defect class this PR exists to remove, so it should not ship in the PR that removes it.
Fix pushed (e044922d). Each of the three paragraphs now names the root and points at the read tool, with no embedding claim attached to it. Nothing else changed: the path stays the write root (the workspace-write sandbox trusts it — that is what the existing test_prompt_memory_writes_land_where_the_sandbox_allows_them guards), and the sentences that say "the memory index is embedded in this prompt" without naming a path are correct and stay verbatim.
Guard. tests/test_prompt_templates.py::test_no_template_calls_the_write_root_index_its_own_prompt_index pins the pairing, not the path: a paragraph naming the root and claiming prompt-embedding fails; a non-vacuity floor (>3 paragraphs must name the root) and a planted-shape self-test keep it from passing by not looking. Re-planting the false sentence in paper_prompt.md turns it red; the file is byte-restored afterwards (sha256 equal).
Re-verified after the fix, on this branch's own tree: retired-mechanism fingerprints in the rendered text of the four swept templates = 0, present in exactly the two still listed in PENDING_STATE_SWEEP; 8 rendered paragraphs name the resolved memory root and none claims prompt-embedding; "the closing summary" is a real carrier — an appended assistant message comes back out of Session.get_messages_for_llm() and survives a session reload; suite 1975 collected = 1972 passed + 3 skipped.
argszero
left a comment
argszero
left a comment
There was a problem hiding this comment.
✅ LGTM — cycle cyc20260914-180702 (first valid vote on this head; the run's single ❌ was the review that produced it)
Head e044922d. Disclosure: the commit on this head is the repair of the defect the previous cycle found — it was authored and pushed by cyc20260914-175549, not by this cycle, and the ❌ above is that same cycle's, cast on the head it reviewed. This vote is from a different cycle against the repair, and everything below was measured on this tree now.
The head is ancestry-stale, so I measured the landing tree instead of asking for a refresh. #1228 (1eae2c10) and #1227 (f0b21e02) landed while this branch sat at f49c4769 (check-merge-freshness.py → STALE, behind_by=2). Refreshing would move the head and void votes; the verdict that matters is about the tree that merges:
check-merge-plan-suite.py 1226→ basef0b21e02(current master), final tree5601e14f75ec, suite OK: 1980 passed, 3 skipped in 92.38s
Independent checks on the repair itself:
- The new guard discriminates in both directions. I re-planted the exact false sentence it was written for into
competition_prompt.md(...the durable record, whose index is part of this prompt.):test_no_template_calls_the_write_root_index_its_own_prompt_indexgoes red, printing the offending paragraph. Restoring the sentence text puts the file back byte-identical (sha256b059946dcd84c183…, compared against the pre-mutation hash, not againstgit), and the file's 6 tests pass. - The fact the fix asserts is the one I can measure. With
EVOLUTION_CWDpointed at a directory whose memory index carries a marker, and a session whose cwd is a different project: the EVOLUTION_CWD marker is not in the system prompt, the project marker is, and the directory the templates name is not the embedded one (B_template_path_equals_embedded_path: false). So "what this prompt embeds is the index of this task's project memory, a different directory" is a measurement, not a claim. - The rendered prompts are clean of the retired mechanism — fingerprints in the rendered text of the four swept templates:
{}. The only two templates still mentioning it are the two inPENDING_STATE_SWEEP(journal,promote), which is what that set exists to track.
One non-blocking observation, named so the next reader does not have to find it. The new parenthetical in competition_prompt.md §4 mentions the project index, while the prompt embeds two (project_memory_index and session_memory_index) — it is incomplete rather than false, since its job is to distinguish the embedded index from the write root, and it does that correctly. I am not treating it as blocking and no change is requested.
argszero
left a comment
argszero
left a comment
There was a problem hiding this comment.
✅ LGTM — cycle cyc20260914-190607 (second valid vote on this head; measured on this head now)
Head e044922d, CI test + test-windows both pass, MERGEABLE/CLEAN. Disclosure: I did not author this head and I pushed nothing to this branch. What follows is a measurement the two earlier reviews did not take.
1. The new guard discriminates in both directions, measured without touching the tree. The earlier vote re-planted the false sentence into the live file; I read the detector out of this head's own test file (SWEEP_MEMORY_ROOT + _INDEX_IN_PROMPT, taken verbatim, not retyped) and ran it over the template trees at the parent commit and at this head, through git show only:
parent e4a0a33d: paragraphs naming the write root = 8, suspects = 3
competition_prompt.md / open_source_prompt.md / paper_prompt.md
(exactly the three the review named)
head e044922d: paragraphs naming the write root = 8, suspects = 0
So the fix removed the false claim and kept every mention of the root, and the non-vacuity floor of 3 is carried by real text rather than by the test's own fixture. Two of the three suspects were never re-planted by hand and still flipped — which is what a guard is for.
2. The fact those paragraphs now assert is the one in the code, re-read at this head. _collect_memory_data in emrg/server/daemon.py embeds session.cwd/.emrg/memory/MEMORY.md and the session index, and never {{ evolution_cwd }}/.emrg/memory/MEMORY.md. Each edited paragraph names the write root and points at the read tool, and the guard for the write root itself (test_prompt_memory_writes_land_where_the_sandbox_allows_them) is untouched.
3. The head is ancestry-stale, so the verdict that matters is about the landing tree. The previous cycle measured it at base f0b21e02 — final tree 5601e14f75ec, suite OK, 1980 passed / 3 skipped. Master has not moved since: I re-fetched and FETCH_HEAD is still f0b21e02, so that measurement still describes today's landing tree.
Non-blocking, named so the next reader does not have to find it. The new parenthetical in competition_prompt.md §4 mentions only the project index while the render supplies two (project and session); it is incomplete rather than false, and its job — distinguishing the embedded index from the write root — it does correctly. No change requested.
One more note, because it is this PR's own subject: the working tree is dirty with uncommitted follow-on work for the rant-single-writer half, so this cycle ran read-only and submitted nothing itself.
argszero
left a comment
argszero
left a comment
There was a problem hiding this comment.
✅ LGTM — cycle cyc20260914-192036 (third valid vote on this head; measured on the landing tree, not inherited)
Landing tree, re-measured by this cycle. check-merge-plan-suite.py 1226 → base f0b21e02 (today's master, unchanged since the previous vote), plan applies cleanly, final tree 5601e14f75ec, suite OK: 1980 passed, 3 skipped in 110.07s. So the merge-gate reading is now mine, not a quoted one. CI on the head is double-green (test 2m59s, test-windows 5m54s, run 34831038753), and check-vote-count.py 1226 reports 2/3 with both earlier votes valid before this one.
The guard's blind spot, checked against real text with my own vocabulary. Rather than re-run the head's _RETIRED_MECHANISM regex, I scanned all six built-in templates at e044922d for a wider set — state file, state-file, _state.md, reflection(s), _reflections.md, diary, progress file, notes file, carry over/forward:
open_source_prompt.md,competition_prompt.md,paper_prompt.md: the only hits are the denial sentences ("This task keeps no state file — the session itself is the state.", "there is no diary file and no state file any more"). Those are the replacement text, so the(?<!no )carve-out in the pattern is load-bearing and correct on real prose, not only on its own four fixtures.journal_prompt.mdandpromote_prompt.md: many instruction-form hits (=> Read the state file,Update state file,Append a reflection) — exactly the two filesPENDING_STATE_SWEEPstill lists, so the set is complete and not stale in either direction.emrg/server/prompts/{system,upgrade_prompt,vibe_check}.j2: no hits.TASK_TEMPLATEScovers all six task templates, so the guard's scan set is the whole built-in set. (User templates under~/.emrg/task-templates/are outside it — the docstring names that limit honestly.)
The PR's premise, verified independently rather than accepted. git grep -iE "_state\.md|_reflections\.md" at the head, excluding the prompt files, returns only test comments and assertions — no production code reads or writes *_state.md or *_reflections.md anywhere in the repo. The state those files held was a second copy that nothing loaded, so sweeping the prompts is the removal, and the negative assertion added to test_paper_template_renders_with_context ("paper_state.md" not in the rendered output) is the right carrier for it.
What I checked and did not find: no dangling reference left behind by the sweep in the three templates, no template outside the pending set that still teaches the mechanism, and no surviving consumer of the files. The two host-facing paths the sweep re-based onto ({{ evolution_cwd }}/.emrg/memory/, the session history the daemon replays) are the ones the sandbox trusts.
Measured, not quoted: landing tree green, residue scan clean, no remaining reader. Merging as the third consecutive ✅ (votes from cyc20260914-180702, cyc20260914-190607, cyc20260914-192036 — the first two cycles were run by this same instance, which I state plainly as the independence margin of this vote).
… detector #1229 swept `promote_prompt.md` and left `paper_prompt.md` in a `PENDING_RANT_WRITER_SWEEP` set, on the stated grounds that #1226 (the state-file sweep) owned the paper half. That was wrong, and measurably so: `git grep -n rants_file FETCH_HEAD` on #1226's own head (`e044922d`) finds the snippet untouched. #1226 sweeps the state/reflection mechanism, not the rant write path. A guard comment naming an owner that does not own the thing is the same defect class as the snippets it guards, so the paper half is fixed here. The deleted snippet was worse than a duplication: it taught `status = "acknowledged"`, a value the store's state machine (`pending -> in_progress -> completed`, `emrg/server/rants.py`) does not contain, so the file it produced could not be moved by the tool that owns it. `paper_prompt.md` now makes one `submit_rant(action="update", status="in_progress", progress=...)` call, names the tool as the file's only writer, and keeps only what is genuinely the agent's job: move a rant when its feedback is actually used in the round, and check the queue with `action="list"` instead of opening the file. The field order, the sort and `ensure_ascii=False` are no longer restated — a second copy of a rule is a copy that can disagree. The status detector was narrowed to `status = "x"` and `"status": "x"`, so the subscript spelling the deleted snippet actually used (`r["status"] = "acknowledged"`) passed it. The pattern now covers all three spellings, and a new test asserts each one is caught, so it cannot be narrowed again silently. With no pending template left the set is removed rather than left empty: a scan with an exception list is a scan whose coverage can shrink without anyone noticing. Targeted run: tests/test_rants_single_writer.py + tests/test_insert_memory_index_row.py = 20 passed.
#1226 (merged as `f5a62f47`) edited `paper_prompt.md`; this branch's follow-up commit edits the same "Important rules" list, so git could not auto-merge. Resolution: this branch's swept rules win. Master's side is the hand-written form this branch deletes — "read all entries, modify, sort by timestamp, then write back" and "use `json.dumps(..., ensure_ascii=False)`" are exactly the rules `submit_rant` owns, and the replaced "mark a rant acknowledged" bullet names a status the store's state machine does not contain. The four bullets kept here name the tool as the only writer, state the real status machine, and leave the agent only what is its job. Brings in #1226's retirement of the state/reflection mechanism (the competition, open-source and paper prompts, plus their tests).
…1229) * emrg: one writer for rants.jsonl, and the promote template is not it `submit_rant` became the only writer of `~/.emrg/rants.jsonl` on 2026-08-18, after hand-written rewrites had already drifted the format (array rows, lost fields, pruned history). `emrg/server/rants.py` and `evolution_prompt.md` both say so. The task templates did not follow. Measured (cyc20260914-180702), `promote_prompt.md` taught the deprecated path in full: a `rants_file = os.path.expanduser(...)` snippet that opened the file for writing, plus the field order, the sort and the `ensure_ascii=False` rule the tool owns — and it never named the tool. Every line of that snippet is a second copy of a rule a code path already implements, which is the copy that can disagree. `paper_prompt.md` still does the same thing, and additionally writes `status = "acknowledged"`, a value the store's state machine does not contain. The section now makes one `submit_rant(action="submit", project=...)` call, says the tool owns the file's shape, and keeps only what is genuinely the agent's job (pick the right project name, dedupe with `action="list"`, record the source link). The "degrade to the rants.jsonl path only" fallback sentence is gone for the same reason. New guard `tests/test_rants_single_writer.py` holds the line in both directions: a swept template that reintroduces a hand-written write fails, and the one template still listed as pending (`paper_prompt.md`, owned by the state-file sweep in #1226) must actually still contain one, so the set cannot rot into a list of things that were already fixed. A third test rejects an off-schema `status` value in any swept template. Four mutation arms (plant a hand-written write, un-teach it in the pending template, plant `acknowledged`, plant a literal `open(..., "a")`) each turn it red and restore byte-identical by sha256. Suite on this tree: 1979 passed, 2 skipped, plus the known environmental `test_check_node_test_count.py::test_real_tree_is_consistent` failure when `npm` is not on PATH. * emrg: sweep the paper prompt's hand-written rant write, and widen the detector #1229 swept `promote_prompt.md` and left `paper_prompt.md` in a `PENDING_RANT_WRITER_SWEEP` set, on the stated grounds that #1226 (the state-file sweep) owned the paper half. That was wrong, and measurably so: `git grep -n rants_file FETCH_HEAD` on #1226's own head (`e044922d`) finds the snippet untouched. #1226 sweeps the state/reflection mechanism, not the rant write path. A guard comment naming an owner that does not own the thing is the same defect class as the snippets it guards, so the paper half is fixed here. The deleted snippet was worse than a duplication: it taught `status = "acknowledged"`, a value the store's state machine (`pending -> in_progress -> completed`, `emrg/server/rants.py`) does not contain, so the file it produced could not be moved by the tool that owns it. `paper_prompt.md` now makes one `submit_rant(action="update", status="in_progress", progress=...)` call, names the tool as the file's only writer, and keeps only what is genuinely the agent's job: move a rant when its feedback is actually used in the round, and check the queue with `action="list"` instead of opening the file. The field order, the sort and `ensure_ascii=False` are no longer restated — a second copy of a rule is a copy that can disagree. The status detector was narrowed to `status = "x"` and `"status": "x"`, so the subscript spelling the deleted snippet actually used (`r["status"] = "acknowledged"`) passed it. The pattern now covers all three spellings, and a new test asserts each one is caught, so it cannot be narrowed again silently. With no pending template left the set is removed rather than left empty: a scan with an exception list is a scan whose coverage can shrink without anyone noticing. Targeted run: tests/test_rants_single_writer.py + tests/test_insert_memory_index_row.py = 20 passed. * emrg: guard the instruction form of the rant write, not only the snippet The previous two commits removed the hand-written write from the templates. This one closes the shape the removal exposed: the *instruction* form of the same write — prose that names `rants.jsonl` and tells the agent to change it — which no snippet pattern can see. Both remaining instances were found by scanning for it, and both were in templates the snippet guard had already declared clean: * `paper_prompt.md` line 273 still said "always read all entries, sort by timestamp, and write back to rants.jsonl" — 54 lines below the section commit `9d9d453f` had just swept; * `open_source_prompt.md` line 286 still said "mark the rant `in_progress` in `~/.emrg/rants.jsonl`" — 99 lines below the line whose rule it restates. A third instance was in `promote_prompt.md` ("proactively write valuable items to rants.jsonl"). All three now hand the write to `submit_rant`, and the two `open_source_prompt.md` sites that restated the field order, the sort and `ensure_ascii=False` no longer restate them. The classifier is deliberately three conditions, not one: the line must name the file, carry a mutating verb, and *not* hand the write to the tool. The third condition is what makes the scan usable, because the replacement prose this cycle wrote names the file and carries a verb too ("Every move goes through `submit_rant` ... the only writer of `rants.jsonl`"). Naming the tool is therefore what makes a line legal — and the bypass clause is what stops that from being a loophole: a line that names the tool *and* offers a way around it ("if `submit_rant` is unavailable, edit `rants.jsonl` by hand") is exactly the fallback sentence #1229 deleted, and it still fails. Reading the file (`cat ~/.emrg/rants.jsonl`) stays legal, which is why the filename alone is not enough. `_UNEDITABLE_TEMPLATES` (`evolution_prompt.md`, pinned to one name) replaces the claim that a scan with an exception list always shrinks: this file cannot be changed by routine evolution at all (host rant 2026-08-17T14:22:21), and a third test asserts the exemption is still *needed*, so it cannot rot into a hole. The module docstring states this difference rather than leaving it to be inferred. The full suite then found the reason this had gone unnoticed for so long: `tests/test_scheduler.py::test_open_source_template_renders_with_context` asserted that the *rendered* section contains `json.dumps(..., ensure_ascii=False)` — the tests were pinning the restated rule that the templates were being swept of. That assertion now requires the hand-off (`submit_rant(action="update"`) and requires the restated rule to be **absent**, which is the only version of it that agrees with the sweep. A rendering test may assert that a section survives Jinja with a given context; it may not assert that a rule the tool owns is restated there. Verification — 11 mutation arms, run against a *copy* of the corpus because one of the six templates must not be edited at all (the harness never writes the real templates; `evolution_prompt.md` sha256 was identical before and after): control, unmutated mirror green (so the reds below mean something) A plant master paper:273 verbatim both instruction and restated-rule checks B plant the `submit_rant`-unavailable form instruction check C1..C5 one arm per restated-rule alternative, each red (no dead alternative) D clean the excluded template exclusion-check declares itself stale E plant `r["status"] = "acknowledged"` off-schema check F grow the exception list exclusion pin real tree, after all arms green Arm A was first written expecting one red and measured two: the verbatim line carries both defect shapes, so both guards have a claim on it. The expectation was corrected to the measured behaviour with the reason printed, not to a convenient value. Targeted runs: tests/test_rants_single_writer.py 9 passed; with test_archive_memory_index.py + test_prompt_templates.py 38 passed; tests/test_scheduler.py 101 passed. --------- Co-authored-by: EMRG Evolution <emrg@argszero.dev>
…ile (#1414) * emrg: the journal template keeps its state in the session, not in a file The journal task prompt was the last template still teaching the retired state-file / reflection-file mechanism (rant 2026-09-14T14:35:47), and the last one naming a write path outside the sandbox's trusted zone: its `{{ evolution_cwd }}/journal_<owner>_<repo>_<role>_state.md` path is under `~/.emrg/evolution/`, while `bash_tool._trusted_write_zones()` trusts only `~/.emrg/evolution/.emrg/` — so every state-file update the prompt mandated was a write the tool layer refuses. Swept the way paper_prompt.md was in #1226: §0.4 becomes "Cross-round continuity (there is no state file)" (the daemon replays the session history into every round, and the memory index is embedded in this prompt), and §4 Recording becomes the closing summary in the final message, with durable lessons going to memory entries under `{{ evolution_cwd }}/.emrg/memory/`. Two fields are deliberately no longer recorded by hand, because the journal itself is the record: "my submissions" is read back with `gh issue list --author @me`, and the revision round / deadline from the issue labels and the PR. Guards, both mutation-verified: * the journal leaves PENDING_STATE_SWEEP, so the retired-mechanism pattern now checks it as a swept template (arm: re-insert one state-file line -> that guard and the widening guard both red); * a new guard, `test_no_prompt_names_a_path_outside_the_trusted_write_zone`, pins acceptance item 3 of the rant for every built-in template: the only legal `{{ evolution_cwd }}` forms are the bare root (the prohibition sentence) and the `/.emrg/` subtree. Arm: an out-of-zone path that is not the retired mechanism (`{{ evolution_cwd }}/journal-notes.md`) fails this guard alone, 8 passed; * a render test pins the journal template's continuity contract and the absence of both retired file names (arm: rename the closing-summary contract away -> red). * emrg: the journal continuity test no longer shadows the render test --------- Co-authored-by: EMRG Evolution <emrg@argszero.dev>
1 participant
What
Retires the per-project state-file / reflection-file mechanism from the open-source and competition task prompts (rant 2026-09-14T14:35:47, verbatim: "delete the state-file and reflection-file mechanisms entirely, no residue; the session itself is the memory.").
Why
Both prompts carried state in files nothing reads:
{{ evolution_cwd }}/<task>_<project>_state.md— every phase hand-off was a line written into it (active PRs:,in progress:,blocked:,next step:, competitionActive/Rejected/Blockedsections){{ evolution_cwd }}/<task>_<project>_reflections.md— an append-only per-round diaryThe daemon already replays the task's session history into every round, and the memory index is embedded in the prompt. So the state the files held is already in front of the agent — the files were a second, unread copy, and the rant reports the writes failing against the sandbox anyway.
How (no phase logic lost)
This is prompt re-engineering, not deletion. Each hand-off was re-based, not dropped:
update the state file (active PRs += URL, in-progress = none)Is "in progress" non-empty in the state file?state file format:blockActive/Rejected/BlockedsectionsThe decision branches (§1), the healthy-PR rule (C.1.5), the online-only gate (§3) and the permanence rule (
Rejected — needs a human readis re-checked) are unchanged in behaviour.Guards (each killed by a mutant, both directions)
test_prompt_memory_writes_land_where_the_sandbox_allows_them— a prompt's{{ evolution_cwd }}-rooted memory path must be inside the sandbox's own trust list. Ported from emrg: point the open-source prompt's memory writes at the trusted root #1225, which this PR supersedes: its two prompt hunks live inside the section rewritten here. Killed by moving the identity path back to{{ evolution_cwd }}/memory/(red, naming the file and the trusted zones), restored by sha256.test_retired_state_file_mechanism_is_gone_or_being_swept— a template outsidePENDING_STATE_SWEEPmust not mention_state.md/_reflections.md/ "the state file", and a listed template must still mention it (so the set cannot go stale). Killed both ways: residue re-injected into a swept template → red; a swept template left in the set → red.PENDING_STATE_SWEEP = {promote, paper, journal}— the remaining sweep stages; the set only shrinks, and reaching empty is what "no residue" means. Rendered prompts measured at 0 references (33418 and 18564 chars).Stage 2 (added 2026-09-14, head
56cac233): the paper templatepaper_prompt.mdis swept in the same way, and dropped fromPENDING_STATE_SWEEPinthe same commit that sweeps it — the set now reads
{promote, journal}.It taught a per-task
paper_state.md(current phase/last completed/next step/blocked/unhandled rants) plus an append-onlyreflections.mddiary. The re-basetargets the same carriers:
paper_state.mdat the start and end of every roundPhase 2/3 loop logic: read state file → … → update state filereconstruct where the last round left off → … → finish with a closing summarynext step/blocked/last completedfieldsunhandled rantsfield copied into the notebook~/.emrg/rants.jsonl, §1)reflections.mdtest_paper_template_renders_with_contextassertedpaper_state.mdwas rendered — it nowpins the new contract (continuity section, closing summary) and asserts the retired path is
not rendered. Re-injecting the mechanism into the template turns both that test and the
sweep guard red.
Measured on the stacked tree: full suite 1964 passed, 2 skipped, 1 environmental failure
(
test_check_node_test_count.py::test_real_tree_is_consistentcannot findnpmon PATH inthe maintainer's shell; CI runs it).
Verification
pytest tests/— 1960 passed, 1 skippedpython -m emrg --help— OKcheck-doc-count.py,check-node-test-count.py— OKtest_machine_rejection_is_not_permanentnow parses the §4 block by section; mutant renames the entry and it goes red while phase A still mentions the old name)