Repository navigation
Releases
v0.20.0
The first unattended write-mode run this project has ever done, and what came
out of it. The run was the point — the audit's one open verdict was that the
--allow-write path had never actually run unattended, which is missing
evidence, not missing code — but it also found a guard that fails open, and the
nightly it was rehearsing would have inherited that.
Upgrade
- The unattended drivers now refuse dirty trees they previously ran on. The
refusal was always the documented contract ("refuses to run on a dirty tree —
unattended changes must be attributable"); on a wide tree it silently did not
happen (see the first entry under Fixed). If a scheduled run of yours has been
starting on a repo with uncommitted work, it will now stop with
dirty tree, refusing unattended runin.loop/unattended.logand exit 1
instead. What to do: commit or stash before the timer fires — that is what
the guard has always asked for. The same tightening makes
unattended-polish.sh's post-run check refuse to vouch for a session that
ended mid-edit (exit 70,UNTRUSTWORTHY), which previously passed silently on
a wide tree. To keep the old behaviour, pin0.19.0— but note that the
old behaviour is abypassPermissionssession starting on work it cannot
attribute.
Fixed
-
The dirty-tree guard answered CLEAN for a tree full of uncommitted work.
git status --porcelain | grep -vq '^?? \.loop/'underset -euo pipefail:
grep -vqleaves at the first line, git takes a SIGPIPE and dies 141, and
pipefail makes 141 the pipeline's status, which theifreads as FALSE. Every
dirty fixture in the suite was one file (~40 bytes of porcelain), so git
always won the race and the guard looked sound; past the 64KB pipe buffer it
is git that always loses. Measured on a 4000-file tree, pre-fix: the polish
driver started abypassPermissionssession on a dirty tree 5/5 runs, its
post-run check passed a session that abandoned 4000 modified files, and the
autoloop driver let sessions commit on top of someone's uncommitted work. All
three sites now share onetree_is_dirtythat captures the porcelain whole
and filters it in-process; a git that fails to answer counts as dirty. -
Nine more defects from the same run, each with its own commit: an arm that
could not write still said it had armed; a backlog rewrite published a partial
read over the user's file; the ignore line written where git never reads it;
max-sessions 0installed a unit that could never run; the provider-limit
wait deferred the signal trap for the whole wait. -
install-timer.shcreated~/.config/systemd/userbefore it could fail.
Aset -eabort between the two mkdirs left that directory on a box that
never had one. Repo-local.loop/now goes first, so residue lands in the
repo's own gitignored bookkeeping dir. -
A failed ledger publish left the previous round's
results.jsonlooking
current. Exit 73 already protects every machine consumer; the refusal now
also tells a human reader the file on disk is from an earlier round. The stale
ledger is still not deleted — erasing a completion record on an error path is
worse than a stale one.
Changed
-
agents/loop-reviewer.mdandagents/loop-verifier.mdhad never been
through a review lens, and two of the nine defects found there were broken
contracts rather than wrong sentences: the verifier was told to echo aLENS:
its caller was never told to send, andMORE BEYOND CAP: <n>had no consumer
anywhere — while "nothing is lost, the next round picks it up" is false on a
dry round, at the 3-round cap, and in report-only mode, which is the
unattended default. Both hand-offs are now wired and pinned by assertions.
Also:Read-only by design.in both frontmatter descriptions was the same
overclaim this repo already banned from those files' bodies, back under a
spelling the fixed-string ban did not cover. -
Six documentation claims the recovered SUSPECTED list was right about,
including the README install command (the release smoke runs
loop-eng@loop-eng, the README saidloop-eng) and the README's account of
two loops in one repo, which described a hash-lock collision that cannot
happen — the second session's contract write is denied outright.
Test harness
- The entry point could print ALL GREEN in three shapes where nothing ran:
an untracked script escaped bothbash -nand shellcheck, zero suites counted
as a pass, and a suite that exited 0 without reachingreportwas "ok". - Six more scans that had stopped checking: the sandbox-leak scan matched
four spellings and missed four ordinary ones; the hooks.json command scan
broke on a JSON reformat (61 → 58 passed, still ALL GREEN); two hash-lock
assertions compared empty to empty on a host with no SHA-256 tool; two JSON
validity checks vanished unannounced without python3; a manifest negative
control passed when its helper errored; a fake PATH named a tool the gate
never uses. - The timer scripts are now in CI's bash-3.2 leg (they were hand-verified
under a real 3.2.57 for several releases, which is not a gate), and the two
unattended suites no longer assert against the ambient environment — this
project's own systemd unit exportsLOOP_ENG_ALLOW_AUTOFIX=1, so a suite run
from inside an unattended session went red for reasons unrelated to the code.
Suite 967 → 1104 assertions, 13 suites, 0 failed; bash 3.2.57 leg green.
v0.19.0
One refusal, and the documentation catching up with the machine. The refusal is
small and the docs are large: a report-only review of the 1858 lines of prose
that had never entered a review lens found 34 claims the code does not support,
including two in the release checklist whose only job is to stop a release on
red, and two in the README that cost a user a wasted night each.
Upgrade
-
An
autolooptimer installed without--allow-writeis now refused.
unattended-autoloop.shhas never had a report-only mode: without
LOOP_ENG_ALLOW_AUTOBUILD=1it refuses at its own entry and exits 1. So
install-timer.sh autoloop <repo>was enabling a unit that failed on every
trigger for the life of the install: no work, astatus=1/FAILURErecord in
the journal, and the one sentence explaining why appended to
<repo>/.loop/cron.log, since the unit routes both of the driver's streams
there — while its ownDescription=called the mode "report-only". The
installer now refuses that combination at install time, names the cause and
the fix, and writes no unit file. This is the rule the installer already
applied to a polish scope that does not exist in the repo ("the unit would
enable cleanly and review nothing every night"); only its coverage was short.The refusal is argv-only and fires before any environment check, so a box
with noclaudeCLI installed is told what is actually wrong instead of being
sent to install a CLI this request never needed.What to do: pass
--allow-writeto schedule real unattended builds — they
modify and commit to your repo with no human in the loop — or install a polish
timer instead, whose no-flag mode is report-only and does useful work. If you
have such a timer installed today it keeps running and keeps failing nightly;
nothing removes it for you, anduninstall-timer.sh autoloopis the way out.
To keep the old behaviour, pin0.18.1.polishis unchanged in every
mode.
Fixed
-
A SessionStart hook could exit non-zero.
hooks/update-notify.shruns
underset -uand promises in its own header never to exit non-zero, but
derived its cache dir from${XDG_CACHE_HOME:-$HOME/.cache}— fatal when
HOMEis unset (an empty one expands fine). Guarded; the dir then resolves
to an unwritable/.cacheand the existing fail-open path takes over. -
The release checklist prescribed a CI check that reports the wrong run.
Both steps inRELEASING.mdwhose job is "do not publish on red" used
gh run list --limit 1. For ~15s after a push GitHub has not registered the
new run, so onmainthat returns the commit before the one being released,
and after a tag push it returns the previous tag's gate run — already green.
This project had caught both shapes in the field (0.16.0 and 0.16.1) and
written the rule down only in a private note, while the authoritative
checklist kept prescribing the broken form. Both steps now select by sha and
by tag. -
README's
LOOP_ENG_ALLOW_AUTOFIXrow had the failure mode backwards. It
said--auto-fixwithout the variable "stays report-only"; the driver
refuses and exits 1, so a cron line missing the variable does nothing at all,
every night, while the table promised nightly review. Report-only is what
omitting the FLAG gives you. -
README's documented hand-resume was denied by this plugin's own gate.
rm -f .loop/active .loop/gate-count .loop/criteria.sha256as one call exits
2: the evidence-gate is PreToolUse, so it reads the whole command string while
activestill exists. Now documented as the two calls it has always required. -
Thirty more claims across
README.md,CLAUDE.md,RELEASING.md,
commands/andagents/, each verified against the code rather than
against another document. The ones that changed what an orchestrating model
would do:/autolooptold it to tick a backlog line the evidence-gate denies
(the lock is file-wide, not per-line); it presented
LOOP_ENG_DISABLE_EVIDENCE_GATE=1as the whole route to a mid-loop contract
change, when the hash-lock is a second layer that exits 77 on every later stop
untilarm-contract.shre-pins it;loop-builderwas pointed at
.loop/contract.mdas the definition of "done", which is.loop/criteria.tsv;
loop-checkerwas told to run the slow full suite every round, against a
design that reserves it for the last; and/polish's degraded mode described
applying fixes with no agent present that may apply one. -
One class of prose defect is now machine-caught.
tests/test-packaging.sh
already banned an overclaim about the read-only agents across the three agent
files;SKILL.mdcarried the same overclaim and was outside that sweep. The
ban now covers it, with a positive assertion beside it.
v0.18.1
0.18.0 widened the backlog grammar in code and left the instructions the model
reads still spelling out the narrow one. Nothing executes differently in this
release; what changes is that the orchestrator's own completion test no longer
disagrees with the machine's.
Fixed
/autoloop's completion prose judged by the literal- [ ]spelling.
0.18.0 taught the runner,count_pendingand the item picker to recognize an
unfinished item on a-,*or+bullet with optional indentation, but
commands/autoloop.md— shipped, model-facing routing instructions — still
decided "is this loop done?" against the narrow grammar at five separate
sites. Read literally, it would call a loop complete while an unfinished
* [ ]or indented item was still pending. The machine gate already caught
that case, so no loop could actually end unverified; the defect was that the
instructions and the mechanism gave different answers, and only one of them
was right. The five completion sites now turn on "unfinished item", defined
once and descriptively, while the two sites that teach which shape to write
still say- [ ]— recommending one spelling while tolerating more is
deliberate. Stop rule 1 reads "no unfinished backlog item remains" rather
than "every item is ticked": the latter would be stricter than the code,
since an ordered-list1. [ ]item is a documented boundary — locked by the
gate, never ticked — and that phrasing would make the rule unsatisfiable on
such a backlog. No script, test or behavior changed; the suite is unmoved at
942 assertions.
Live-install smoke
Passed on Claude Code 2.1.278 against a real marketplace install of 0.18.1 from
the GitHub source into a throwaway CLAUDE_CONFIG_DIR, hooks instrumented in
the cache copy so each verdict is a machine fact. Required this release because
it touches commands/ — and directly relevant, since step 6 is what proves
${CLAUDE_PLUGIN_ROOT} still expands inside the command markdown this release
edits.
armed from …/plugins/cache/loop-eng/loop-eng/0.18.1/…— the cache copy under
test, not the marketplace clone.- evidence-gate denied
echo hello > .loop/evidence/smoke.log; file absent,
markerEGDENY root=…/0.18.1. - stop-gate on a RED contract:
SGBLOCK-contract×3 thenCEILING-RELEASE,
every block on the contract-unsatisfied path — none on missing-runner,
dedup-replay or timeout. On diskgenerated_by: run-contract.sh,
all_green: false. - the edited
/loop-eng:autoloopcommand expanded and ran:all_green: true
on two criteria, acceptance artifact written,.loop/activelifted by the
gate itself, and the marker log empty — the same instrumentation that
recorded four markers under the RED contract recorded none here.
v0.18.0
The backlog half of a loop accepted less than it locked. The evidence-gate has
always frozen a backlog line on a tolerant pattern, while the runner ticked one
strict shape — so a line in the gap was untickable by anyone: the model's
write denied, the box unable to move, and an unattended driver re-picking the
same item until its circuit breaker fired. This round makes the runner accept
exactly what the gate locks, moves the counters that had to follow it, and
closes two writes that could publish a partial result over a whole one.
Minor, not a patch, on purpose. Nothing here adds a feature. The bump is
owed because a released artifact now accepts input it used to refuse — the
mirror image of the call 0.17.0 made for a new refusal — and because an
unattended run's exit code can move as a direct result (see Upgrade). A
scheduler can observe that; a version string is the only advance signal a user
on ^0.17 gets before their next nightly behaves differently. To keep the old
behaviour, pin 0.17.0.
Upgrade
- The runner now ticks backlog shapes it used to walk past. An optional
indent, a-,*or+bullet, and any whitespace — or none — between|
andverify:. That is exactly the patternhooks/evidence-gate.shalready
locks, so the set of lines the gate freezes and the set the runner can check
off are the same set again. If your backlog has indented or*-bulleted
items, boxes that never moved before will now move on their own; the tick
preserves your indentation and your marker rather than normalizing to
- [x], because ticking a box is not reformatting someone's markdown.
Ordered-list markers (1. [ ]) stay outside the grammar on every side —
locked by the gate, never ticked, and deliberately not counted as pending, so
a driver is never pinned on an item nothing can check off. - A scheduled
/autoloopcan now exit 1 where it used to exit 0.
unattended-autoloop.shcounts pending items and picks the next one in that
same widened grammar. A run that met one of those shapes previously logged
backlog empty — doneand exited 0 over unfinished work; it now keeps
launching sessions against those items, and if it stops with any still
pending it exits 1, as it has always done for a backlog it could not drain.
That is the fix rather than a regression — but if you alert on the driver's
exit status, expect jobs that were green over an unfinished backlog to start
failing honestly. The README's documentedbacklogcriterion was widened the
same way and for the same reason: anchored at column 0 with a literal-, it
reported PASS over an unfinished* [ ]or indented item.
Fixed
- A backlog line could be locked and untickable at the same time. The gate
denies model writes to any.loop/backlog.mdline matching
|[[:space:]]*verify:, while the runner required the literal| verify:
behind a 6-character- [ ]prefix.|verify:with no space, a TAB after
the pipe, two spaces, an indented item, a*or+bullet: each was frozen
by the gate and invisible to the runner, so the box could never move and the
loop could only end at a stop rule or a human disarm. Fixed on the strict
side, restoringlocked ⊆ tickable— narrowing the gate instead would have
satisfied the same arithmetic while producing a box a model can type, which
is the one thing this plugin exists to prevent. - A TAB-indented
#commentincriteria.tsvforced the contract red on
every stop.run-contract.shprobed for a leading#after splitting the
line into TAB columns, whilearm-contract.shprobes the whole line — so
<TAB># disabled<TAB>…armed clean and then failed closed as "partly parsed"
on every stop attempt, withcriteria.tsvalready locked and only a human
disarm able to clear it.<space><TAB># disabled<TAB>cmdwas worse: the id
column was a non-empty space, so the commented-out criterion ran. The
comment and blank probes now sit above the split in both scripts. Their
malformed-line warning was reworded to match: it blamed columns "separated by
SPACES" on lines whose indent is a TAB, in a file that contains no spaces
between columns at all, which is what made the original incident hard to read. - A ledger that could not be published exited with the contract's verdict
anyway.mv "$TMP" "$RESULTS"was the one unchecked write in the runner, so
a hygiene criterion that sweeps temp files (find . -name "*.tmp.*" -delete,
make clean) could delete the temp ledger mid-run and leave the previous
contract'sresults.jsonon disk as the surviving record — a frozen
all_green: truethat the orchestrator reconciles against and then reads as
"no progress" forever. It now fails closed with exit 73 (EX_CANTCREAT). The
stop-gate was never fooled: it branches on its own re-run, not on this file. - A backlog rewrite that lost a write truncated the live backlog. The
cat-back into.loop/backlog.mdtruncates at redirect setup, so it is safe
only if every write to the temp copy landed. Two ways it was not: the-1
poison sentinel was clobbered by the first ticked item (a 3-item backlog
rewritten to 0 bytes, run still exiting 0), and the appends were unchecked, so
a write failing mid-rewrite published a prefix and reportedall_green: true
over it. It takes a.loop/write failing mid-run to reach — ENOSPC first —
and no model action can: the gate denies writes to a backlog carrying verify
commands. It is worth hardening because.loop/is gitignored and the rewrite
is in place, so the user's items are simply gone. - Two enforcement arms were held in place by nothing. Deleting the
systemctl --user enable --nowhalf ofinstall-timer.sh's install — which
ships exactly the trap that script exists to kill, "installed but never
enabled, so they silently never run" — survived the whole suite; the evidence
was already being recorded and then truncated before anything read it.
Dropping either redirect on the backlog's verify command survived too: without
</dev/nulla stdin-reading command eats the remaining backlog items out of
the enclosing loop, and without>/dev/nulla printing command (the
README's ownnpx vitest runexample) writes its output into the middle of
results.json, which still exits 0 and still allows the stop — only the JSON
stops parsing. Each mutation now turns the suite red. Suite: 865 → 942
assertions, 13 suites, shellcheck-S warning0 findings.
Live-install smoke
Passed on Claude Code 2.1.278, against a real marketplace install of this
release from the GitHub source (sdsrss/loop_eng) into a throwaway
CLAUDE_CONFIG_DIR, with the hooks under
plugins/cache/loop-eng/loop-eng/0.18.0/ instrumented so every verdict is a
machine fact rather than a model's report:
- arm cited the cache copy under test —
armed from …/plugins/cache/loop-eng/loop-eng/0.18.0/skills/loop-eng/scripts/arm-contract.sh,
not theplugins/marketplaces/clone. - evidence-gate denied
echo hello > .loop/evidence/smoke.log(the Bash
form — the Write form false-PASSed while smoking 0.17.0). File absent
afterwards, and the marker recordedEGDENY root=…/plugins/cache/loop-eng/loop-eng/0.18.0, soCLAUDE_PLUGIN_ROOT
reached the hook process. - stop-gate blocked a RED contract three times and then released at the
ceiling, twice over: markersSGBLOCK-contract×3 →CEILING-RELEASE, ×2
cycles. Every block took the contract-unsatisfied path — none took the
missing-runner, dedup-replay or timeout exits, which is what distinguishes a
healthy block from a broken install. On disk:generated_by: run-contract.sh,all_green: false. ${CLAUDE_PLUGIN_ROOT}in command bodies expanded: a full
/loop-eng:autolooprun armed, reachedall_green: trueon two criteria,
wrote the acceptance artifact, and lifted.loop/activeitself. The marker
log was empty for that run — the same instrumentation that recorded six
blocks in the step above recorded none here, which is the control that makes
the six meaningful.
v0.17.0
0.17.0 — 2026-09-20
The completion invariant had one input a model could still write, and one branch
order that let the wrong script answer for a contract. Both are closed, and the
three arms that a mutation could delete without turning the suite red are now
pinned.
Minor, not a patch, on purpose. Nothing here adds a feature; the reason for
the bump is that a released artifact now refuses something it used to accept,
and a version string is the only signal a user on ^0.16 gets before their
next loop behaves differently. It is the same call 0.15.0 made when
install-timer.sh began rejecting an install it had accepted. To revert the
new denial without downgrading, set LOOP_ENG_DISABLE_EVIDENCE_GATE=1 (which
turns the whole PreToolUse gate off — it is the human escape hatch, not a
per-rule switch); to revert the release, pin 0.16.1.
Upgrade
- While a loop is armed,
.loop/verify.shis now read-only to the model.
Writing, editing or removing it through Write/Edit/MultiEdit/Bash is denied
the same way.loop/criteria.tsvalready was, and creating one is denied too.
Authoring averify.shbefore arming is unchanged, running it is unchanged,
and once the loop disarms the file is writable again — so an ordinary legacy
loop sees no difference. If you have a workflow where the model rewrites
verify.shmid-loop, it will now get anevidence-gate DENIEDinstead: split
it (rm .loop/activefirst), or use the documented human escape hatch
LOOP_ENG_DISABLE_EVIDENCE_GATE=1. - A broken install now blocks the stop instead of quietly allowing it. If
.loop/criteria.tsvis present butrun-contract.shcannot be found — an
interrupted/plugin update, or a Stop hook registered by a path outside the
plugin root — the gate now fails closed even when a legacyverify.shsits
beside it. Previously a greenverify.shanswered in its place: the stop was
allowed and.loop/activeremoved, so the loop ended looking finished. If you
hit the new block, its stderr names the runner path it looked for — reinstall
with/plugin update loop-eng, or re-register the Stop hook by the plugin's
own path. To end such a loop without verifying it,rm .loop/active, as
before.
Fixed
- A model could rewrite its own gate. In a legacy loop — one armed without a
criteria.tsv, whicharm-contract.shstill supports —.loop/verify.sh
is the contract: the stop-gate executes it and nothing else. It was the one
gate input missing from the evidence-gate's protected set, and unlike
criteria.tsvit has no hash-lock behind it to catch the drift, so rewriting
it toexit 0produced a passing stop that nothing downstream could
distinguish from an earned one. That is the exact claim this plugin exists to
make impossible. Severity is high and reachability is low: the current
/autoloopand/polishalways arm with acriteria.tsv, so the exposed
shape is a hand-armed or leftover.loop/. Twelve assertions now cover it,
including the one that must NOT flip —bash .loop/verify.shis still
allowed, because a frozen gate still has to run. The close is not total, and
the asymmetry is worth knowing:criteria.tsvhas run-contract's hash
re-derivation behind the gate,verify.shhas nothing behind it, so the Bash
verbs outside the gate's conservative pattern —ln,install, an
interpreter one-liner, a path held in a variable — still reach it. Arming with
acriteria.tsvis the shape that gets the full guarantee. - A green legacy script could answer for a red contract, and disarm the loop
on its way out. The stop-gate resolved its contract source in the order
criteria.tsv→ legacyverify.sh→ missing-runner-fail-closed, so a tree
holding both files with no runner present took the legacy branch: the
criteria.tsvthe loop was actually armed with was never executed, and a
verify.shexiting 0 both allowed the stop and removed.loop/active. The
documented behaviour — fail closed on "acriteria.tsvwhose runner it cannot
find" — did not hold whenever averify.shsat beside it, and the reachable
cause is the same interrupted/plugin updatethat removes the runner while
leaving the rest of.loop/alone. The missing-runner arm now precedes the
legacy one;verify.shstill answers for loops that have nocriteria.tsv. - Three enforcement arms were held in place by nothing. Deleting
MultiEdit|
from the evidence-gate's write-tool arm, breaking thepython3fallback
parser's command extraction (the whole Bash branch in jq-less environments),
or gutting the stop-gate's no-timeout-binary path (how the contract runs on
a stock macOS) each left all 834 assertions green. Each mutation now turns the
suite red. Suite: 834 → 865 assertions, 13 suites, shellcheck-S warning
0 findings, six bash-3.2-floor suites re-verified under a real 3.2.57.
v0.16.1
One fix, found by measuring the loops rather than reading them, plus the cost
table that measurement produced.
Upgrade
- A scheduled run will now take as long as you told it to. Until this
release both drivers were cut off after ten minutes by a CLI ceiling neither
of them set (see Fixed below), so a nightly job has been finishing far inside
its budget and reporting success. It will now run up toLOOP_ENG_MAX_MINUTES
— 120 minutes for polish, 240 for autoloop — and consume tokens for that
whole time. Nothing to do if those defaults are what you want; lower them, or
exportCLAUDE_CODE_PRINT_BG_WAIT_CEILING_MSyourself to keep the old
behaviour, if they are not. The measured shape of a run is now in the
README's "What a run costs".
Fixed
- An unattended run was bounded by a ceiling neither driver set, twelve to
twenty-four times shorter than the one it did. In print mode the CLI waits
for still-running background tasks, then terminates them and exits 0 —
afterCLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS, whose default is 600000 (10
minutes). Both loops dispatch subagents the harness may run in the
background, so that default, notLOOP_ENG_MAX_MINUTES(120 for polish, 240
for autoloop), was the real bound on every scheduled run. Nothing downstream
could notice: the truncated session exits 0 withis_error: false, a
report-only polish is exempt from the post-run check, and the autoloop driver
reads that exit as a finished round. Found by measurement rather than by
reading — a headless/polish hooks/reportedsubagent_stats
killed.system: 1with 4 of 5 dispatches completed, and still exited 0; the
same scope with the ceiling lifted completed 18 dispatches (4 reviewers,
12 verifiers, 2 workers) in 25 minutes. Both drivers now hand the session
CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS=0, leaving thetimeoutwrapper as
the single budget it was written to be; exporting the variable yourself still
wins. The suites gained the piece that made this invisible — the stub
recorded argv but not the environment, so a bound the driver never set was
one no assertion could see.
Changed
- The README says what a run costs, from two measured runs rather than an
estimate. A plugin whose pitch is "leave it running" owed a number and had
none. An/autoloopround fixing a failing assertion: 3 dispatches, 25,293
output tokens, 5.7 minutes. A/polishmacro round over four files: 18
dispatches, 354,188 output tokens, 24.9 minutes. The four token classes are
listed apart on purpose — cache reads are 89% of the polish traffic and the
cheapest class, so one summed figure would overstate the load about 9× — and
the dollar column is labelled as the list-price computation it is, which is
not what a subscription pays. The note that makes the table reproducible is
the one that cost the most to learn: readmodelUsage, not the top-level
usageblock, which covers the main thread's last turn and counts no
subagent at all. - The unattended section says how far to trust itself. Closing the audit's
six--allow-writeblockers moved that path from "not production-grade" to
usable, and every guard is now documented mechanism by mechanism — but the
README stated no posture at all, so the only readiness verdict a reader could
find was the one in the audit report, which is untracked and was written
against 0.14.0. The new paragraph says what backs the write path (a test
suite and a live-install smoke) and what does not (a record of long
unattended write runs), and keeps report-only as the mode to schedule first.
Deliberately no assertion count: the README cites none anywhere, and a
hard-coded one goes stale the next time a suite grows.
Live-install smoke: PASS (Claude Code 2.1.278, headless, throwaway
CLAUDE_CONFIG_DIR, GitHub-source install of this release's own content on
main — no source-type disclosure owed). Live cache copies instrumented, so
each verdict is a marker on disk: the evidence-gate's deny() fired with
CLAUDE_PLUGIN_ROOT resolved to the real
plugins/cache/loop-eng/loop-eng/0.16.1 path and the file never landed;
armed from …/0.16.1/…; exactly three SGBLOCK markers then
CEILING-RELEASE on a red contract, with the ledger machine-written
"all_green": false; and /loop-eng:autoloop reached ALL GREEN, left a
two-criteria ledger, and cleared active, gate-count and criteria.sha256
with zero blocks.
v0.16.0
Closing out the 2026-09-20 production-readiness audit: 0.15.0 took every P0 and
P1, this entry takes the P2 and P3 remainder. Each item keeps the project's own
discipline — the assertion that would have caught it first, then the fix.
Upgrade
-
A backlog box is now ticked by a command, not by a claim.
.loop/backlog.md
was the last link in the completion chain a model could simply type: the
all-boxes-ticked check read a file the orchestrator writes, so "tick a box
only after the checker reports ALL GREEN" was a red line honoured rather than
a fact produced. A line written- [ ] <item> | verify: <cmd>is now ticked
byrun-contract.shwhen that command exits 0, on every stop attempt, with
the outcome recorded in.loop/results.jsonunder"backlog"; while the loop
is armed the evidence-gate denies model writes to a backlog carrying any such
line. Only pending lines are re-verified, so the cost is proportional to
work remaining rather than to work done. A red backlog item does not turn
a green contract red — the backlog is progress, and draining it is the
orchestrator's job across rounds, not one stop attempt's.Opting in is what locks the file, so nothing changes for a backlog
without| verify:commands: nothing runs, nothing is denied, and the
orchestrator ticks boxes as before. That shape remains a trust boundary and
is now labelled as one. README also spells out thebacklogcriterion it had
referred to without ever defining:! grep -q '^- \[ \]' .loop/backlog.md. -
The evidence-gate now denies
rm -rf .loopwhile a loop is armed. That
one command takes the stop-gate's marker, the hash-lock and the evidence
ledger together, so however innocently it is typed it is a disarm — and it is
the command this README hands humans for cleanup, which is what made it the
likeliest accidental one. The refusal names the two-step form:rm .loop/activein one call, thenrm -rf .loopin the next. A subpath is
unaffected (.loop/state.mdwas never guarded and still isn't), and once the
loop is over the single command goes through unchanged. Humans keep
LOOP_ENG_DISABLE_EVIDENCE_GATE=1. -
install-timer.shnow runsclaude --versionunder the unit's own PATH
before writing anything. Resolving the binary was never the same as proving
it runs:command -vsearches the installing shell's PATH while the unit
hardcodes a minimal one, so an npm/nvm#!/usr/bin/env nodeshim resolved
cleanly and exited 127 at 03:00 with the error only incron.log. A failed
probe refuses the install and prints the exact command to reproduce it.
LOOP_ENG_TIMER_SKIP_PROBE=1is the way past it for a binary whose
environment the probe cannot reproduce. -
unattended-polish.sh --auto-fixnow exits 70 instead of 0 when its result
is not trustworthy.claude -pexits 0 whether the session converged,
stopped on a regression, or ran out of turns mid-edit. The driver now
establishes the two facts it can for itself: the tree must be clean
afterwards, and an optional project command in the newLOOP_ENG_POST_CHECK
must pass. 70 isEX_SOFTWARE, distinct from the session's own status, which
is still passed through untouched. The tree is left exactly as the session
left it — reverting a half-applied fix would destroy the evidence on the one
run that needs looking at. Report-only is exempt. -
The autoloop driver's circuit breaker grew a second arm. The existing one
is keyed to commits, which answers "did anything happen" and not "did the
backlog move": a session that commits real work and leaves its line unticked
reset the counter, so one item could consume the entire session cap with
every session logged as progress (reproduced at 8/8). It now also stops after
LOOP_ENG_MAX_ITEM_SESSIONSsessions (default 2) on the same item. Set it to
0for an item that legitimately spans sessions.
Changed
/polishconverges on deferred findings instead of re-confirming them
every round. A finding deferred under the public-contract stop rule is by
definition never fixed, so nothing moves it out of the code — and with a line
number in the dedup key it re-entered as "fresh" after every fix round that
shifted lines above it, was re-verified into the same CONFIRMED verdict, and
was deferred again. It burned a verifier pass per round and kept the loop
alive on a finding it had already decided not to act on. Deferrals now go to
.loop/polish-deferred.mdkeyedfile|summarywithout the line — the one
class where line-less dedup cannot lose a real finding, because the outcome
is fixed in advance. The dry-round test now asks whether anything entered the
FIX QUEUE rather than whether anything was confirmed, which is what the stop
rules already said and Phase 2 did not.- The checker now reads
.loop/criteria.tsv, the contract that actually
runs. Verify commands had two sources of truth —contract.mdfor the
checker,criteria.tsvfor the gate — both model-written, with nothing
binding them, so a round could go green against one while the other decided
otherwise.criteria.tsvwins because it is the file the stop-gate executes
andall_greenis computed from it alone; a disagreement is now itself a
reportable finding. /autoloopstep 3 reconciles the report against the ledger before ticking
a box. A checker report is a claim andresults.jsonis a run; there was
no branch for "report green, ledger red", so the disagreement would surface
as a blocked stop with no round left to fix it in. Step 3 now refreshes the
ledger, treats any red criterion belonging to the current item as a failed
round whatever the report said, and treatsmalformed_linesorerroras
never-green. The wrap-up's separate refresh is gone — it is this one.- The contract template's fast subset no longer ships
npm test. The
stop-gate runs that subset on every stop attempt under a 100s budget; a
typical JS suite overruns it, three fail-closed timeouts reach the 3-block
ceiling, and ALL GREEN can then never be machine-confirmed at all. The
examples are scoped commands, and the unscoped one sits in the block already
labelled "final round". - The three judgment agents no longer claim "no write access by design".
They have no Write or Edit tool — that half is real and enforced by the tool
whitelist — but they all have Bash, which writes. The prompts now say the
enforced part as enforcement and the rest as the red line it always was.
README's safety table gains the orchestrator row it was missing: it runs in
your session withWriteandBash, and what is mechanical about it is that
the evidence ledger is denied to it by the same hook as to everyone else. - A tag push now runs a release gate.
.github/workflows/release.ymlfires
onv*: it re-runs the full test matrix against the tagged tree (by calling
test.yml, so there is one definition of "the suite" rather than two that
drift) and asserts that the three manifest version fields, the CHANGELOG's
dated section and the tag all say the same thing — plus that no
## Unreleasedwas left behind. A tag whose manifests disagree with it
installs cleanly and then serves the wrong version forever, and until now the
only thing comparing them was a line in a checklist. The gate has
contents: readand publishes nothing:gh release createstays a
person's step, and so do RELEASING.md's live-install smoke and post-ship
identity diff. CI'snpm i -g @anthropic-ai/claude-codealso gets three
attempts with a backoff, so a registry blip cannot be what turns the manifest
gate off. - The shellcheck gate moves from
-S errorto-S warning. Thirteen
warnings sat unchecked behind it and they were not cosmetic: nine were SC2164,
acdwith no|| exit— in a test suite, where a failedcdinto the
sandbox means the remaining assertions run in the real working tree and start
deleting.loop/files there. The rest were$?read from a condition
instead of a command (SC2319, a live trap once the gate rises) and two
unused-looking variables. All thirteen are fixed; the two deliberate
exceptions carry an inline# shellcheck disable=with a reason.-S style
stays out — SC1091 alone is 12 hits with nothing to fix. - Three README sections that restate repo facts now derive from them. The
env-var table was missingLOOP_ENG_PLUGIN_CACHE_DIR; the layout block named
two of fourhooks/files and called sixskills/loop-eng/scripts/entries
"unattended runner"; and two paragraphs disagreed about how many scripts hold
the bash-3.2 floor (four in one, five in the Requirements table — five is
right, andupdate-notify.shwas the one going unmentioned even though a
SessionStart hook is precisely what stock macOS bash 3.2 runs in every real
session).test-packaging.shnow reads the source of truth for each —
git ls-files, the scripts' ownLOOP_ENG_*reads, and the list
test.yml's bash-3.2 leg syntax-checks — so the next addition is covered the
day it lands rather than the day someone remembers. .loop/state.mdsays out loud that nothing reads it. ItsStatus:line
looked like a completion signal and is prose — no hook, script or gate has
ever read this file. It is now labelled advisory, with the machine answer
named (results.json'sall_green, and the ticked boxes) and the tie-break
stated: if the two disagree, the ledger is right and state.md is stale. The
template also gains the## Deferred (not loopable)heading the roadmap
triage step has always told the orchestrator to write here.allowed-toolslistsAgentalongsideTask. The subagent tool's
current name isAgent;allowed-toolsis a pre-authorization list, so
naming only the old one costs a permission prompt on every dispatch in...
v0.15.0
Everything the 2026-09-20 production-readiness audit rated P0 or P1, fixed with
a reproduction first and a failing assertion before each change. Suite 477 → 600
assertions across 13 suites (a new tests/test-harness.sh); the six
bash-3.2-floor suites re-verified under a real 3.2.57. Minor, not patch: several
user-visible defaults change below.
Upgrade note — read this if you schedule the unattended drivers.
- Two timers on one repo at the same minute is now refused at install time.
Both modes default to--time 03:00, and the drivers cannot share a working
tree. If you run both timers against one repo today,install-timer.shwill
refuse the next re-install of the second one. Action: re-run it with a
different time (--time 04:00). Nothing breaks until you re-install; existing
units keep running, and from this version the loser simply exits 69 instead of
editing the tree underneath the winner. - Two new exit codes.
69(EX_UNAVAILABLE) = another driver holds the
repo lock;143= the driver was signalled and terminated its session.
Deliberately distinct from the75these drivers use for provider limits.
Action: if you alert on non-zero exits, decide which of these are noise. - A failure is no longer reported as a provider limit just because the code it
was working on mentions one. Runs that used to exit75("try again later")
now surface their real exit code, and124is reported as the timeout it is.
Action: monitoring that keyed on75will start seeing the true failures it
was masking. unattended-polish.shsessions are now actually killed at the budget
(timeout -k 30, which its autoloop sibling always had). A session that
ignores SIGTERM no longer runs pastLOOP_ENG_MAX_MINUTES.- Contributors:
tests/test-manifest.shandtests/test-hooks-json.shnow
FAIL on a host with nopython3/jqinstead of reporting0 passed, 0 failedand exiting 0. Action: install either one. CI has both on all legs.
Revert path: pin 0.14.0 in your marketplace entry. Every new behavior above is
in the drivers, the installer or the test harness — no .loop/ on-disk format
changed, so moving between the two versions needs no migration.
Live-install smoke: PASS (Claude Code 2.1.278, headless, throwaway
CLAUDE_CONFIG_DIR, GitHub-source marketplace install of this release's own
content on main — so no source-type disclosure is owed). Each step asserted on
state the mechanism writes, with the live cache copies instrumented so the
verdicts are machine facts rather than model reports:
- evidence-gate: the instrumented
deny()fired (EGDENY: raw evidence under .loop/evidence/), the file was not created, and the denial names the real
absolute runner path underplugins/cache/.../0.15.0/rather than the
<loop-eng plugin root>placeholder — sohooks.jsonauto-loaded and
CLAUDE_PLUGIN_ROOTreaches hook processes. - arm-contract:
armed from …/plugins/cache/loop-eng/loop-eng/0.15.0/…, the
version-pinned copy that enforces, not theplugins/marketplaces/clone. - stop-gate: exactly three
SGBLOCKmarkers (=MAX_BLOCKS) on a red
contract, and.loop/results.jsonmachine-written byrun-contract.shwith
"all_green": false. ${CLAUDE_PLUGIN_ROOT}in command bodies:/loop-eng:autolooparmed,
reached ALL GREEN in cycle 1/5, lifted the gate itself, and left a two-criteria
ledger with"all_green": true.
One observation worth keeping, and the reason the dispatch guidance above was
rewritten rather than deleted: on this run both subagent dispatches detached to
the background despite the synchronous request, costing two extra turns and
producing one duplicate (read-only) checker dispatch. The 0.14.0 smoke saw
synchronous dispatch on this same CLI version, so it is not a stable property.
It did not produce a false green — the ledger stayed machine-written throughout,
which is the guarantee that does not depend on dispatch semantics.
Test blind spot: a safety default could be deleted and the suite stayed
green. Both unattended drivers hand claude an argv that is their entire
contract with the session, and the stub in each suite ignored it. Measured, not
argued: deleting $MODE from unattended-polish.sh's -p "/polish $SCOPE $MODE" — so every scheduled run auto-fixes the repo under bypassPermissions
instead of reporting — kept tests/test-unattended-polish.sh at 39 passed / 0
failed. Swapping /autoloop for /polish and bypassPermissions for default
in unattended-autoloop.sh kept its suite at 41 passed / 0 failed. report-only
is that driver's only write protection, and nothing was watching it.
Both stubs now record their full argv (STUB_ARGV_LOG, one argument per line)
and each suite asserts what actually goes out: the command, the scope, the
report-only default and its removal only under the two-key --auto-fix +
LOOP_ENG_ALLOW_AUTOFIX=1 opt-in, --permission-mode bypassPermissions, and
the per-driver turn cap (120 / 150). Each refusal path is asserted to invoke no
session at all, rather than merely to exit non-zero. Suite 477 → 490 assertions;
the two mutations above now fail 1 and 2 assertions respectively.
No runtime script changed here — this is the gate that was missing, not a
behavior fix.
A suite that ran no assertions is no longer reported green.
tests/test-manifest.sh needs python3 and tests/test-hooks-json.sh needs
jq or python3; on a host with neither, each printed 0 passed, 0 failed,
exited 0, and run-all.sh printed ALL GREEN for a run that checked nothing
about the two manifests or about hooks.json. Reproduced with a PATH holding
neither parser. lib.sh's report() now fails when PASS and FAIL are both
zero, and the new tests/test-harness.sh pins that contract — including that an
all-red suite (PASS=0, FAIL>0) still fails for the ordinary reason — plus
the consequence itself: both parser-dependent suites are run under that
restricted PATH and asserted to exit non-zero. Upgrade note for contributors:
on a box without python3/jq those two suites now go red instead of quietly
passing. Install either one; CI already has both on all three legs.
The stop-gate's green path clears three files, and only one was watched.
Removing "$SHA_LOCK" and "$COUNT_FILE" from hooks/stop-gate.sh's green
rm kept tests/test-stop-gate.sh at 33 passed / 0 failed. Both leftovers bite
the next loop: a stale criteria.sha256 locks a contract that no longer
exists, so the next arm's criteria.tsv fails the hash check and every stop
after it exits 77 "tampered"; a stale gate-count starts that loop partway to
the 3-block ceiling. The green-path test now arms both files first — the first
draft asserted their absence over files the setup had already deleted, so it
passed against the very mutation it was written to catch — and asserts all three
are gone. Suite 490 → 504 assertions across 13 suites.
A criterion could delete the criteria that came after it, and the ledger said
ALL GREEN. run-contract.sh streamed criteria.tsv with while … done < "$CRIT", so a criterion that truncated or rewrote that file made every line
after it vanish mid-read — silently, at EOF. Not "skipped", not "malformed":
absent.
printf 'one\ttruncates\t: > .loop/criteria.tsv; true\ntwo\tred\tfalse\n' > .loop/criteria.tsv
→ exit 0, results.json holds only "one", "all_green": true
The authored contract's second criterion was false. Neither the vacuous guard
nor the partial-parse guard can see this, because from their side the contract
simply was one line — which makes it the one gap in "passes: true can only
come from running the command".
Two halves, mirroring the two questions a ledger has to answer. What ran:
the criteria loop now reads a private snapshot taken after the hash check, so
the executed set is the set that was read and (when armed) hash-verified,
whatever the commands do to the file afterwards; an appended criterion is not
executed by the run that appended it. Whether the result may be reported:
when the loop is armed with a hash-lock, criteria.tsv is re-hashed after the
last criterion and a mismatch writes a tampered ledger and exits 77. That
post-run check is gated on "a lock was checked at start", not on the lock still
existing, so deleting criteria.sha256 mid-run is not a bypass.
run-contract.sh now needs cp alongside the mv/rm/mkdir/cut/date/
tail/sed it already required; both restricted-PATH fixtures list it. Suite
504 → 517 assertions; 9 of the 13 new ones fail against the pre-fix runner.
A criterion with an empty description bricked the loop that armed it.
id<TAB><TAB>cmd is three real TAB-separated columns with a blank middle one.
IFS=$'\t' read -r id desc cmd looks like the right spelling and is wrong in
one silent way: TAB is IFS whitespace, so bash collapses runs of it — the line
came back as desc=cmd, cmd="", i.e. malformed.
arm-contract.sh carried four different splits of that same line: two
awk -F'\t' (which does not collapse) and two IFS=$'\t' read (which does).
They disagreed here and only here. The awk pair called the line runnable, so
arming warned about nothing and pinned the hash; the two read loops saw an empty
command and skipped it, so neither the static parse check nor the red-check ever
looked at it; and run-contract.sh, reading it the collapsing way, called it
malformed and failed closed on every stop — with a message blaming SPACES in
a file that contains none. The evidence-gate had locked criteria.tsv by then,
so the loop could only end by hitting a stop rule.
Both scripts now split on the first two TABs: everything after the second is
the command, an empty description is legal, and fewer than two TABs / an empty
id / an empty command is malformed. Five parse sites became two (one per
script). Both mal...
v0.14.0
Two gaps this repo had already written down and left open: a wall-clock budget
that silently did not apply on macOS, and a bash-3.2 compatibility claim that
lived only in a code comment. Test suite 468 → 477 assertions (counted by
summing bash tests/run-all.sh, at the previous release commit and at this one).
The 0.13.0 entry's "456" is not wrong so much as early: tests/test-packaging.sh
landed later in that same cycle carrying exactly the missing 12, so a fresh count
of the v0.13.0 tree is 468. Both numbers here were measured, not carried forward.
Behavior change, macOS only — read this if you schedule /polish.
unattended-polish.sh probed only timeout, so on a mac with Homebrew
coreutils — where GNU coreutils installs the binary as gtimeout — a scheduled
polish ran with no wall-clock cap, while the autoloop driver and the
stop-gate, both of which fall back to gtimeout, stayed bounded. The probe is
now timeout → gtimeout, so on such a host a nightly polish is from now on
killed at LOOP_ENG_MAX_MINUTES (default 120 minutes) where it previously
ran to completion. To keep long runs: raise LOOP_ENG_MAX_MINUTES (0 is
refused and falls back to 120 — timeout 0m means "no limit", which is the
opposite of what a budget knob's lowest value should do), or pin 0.13.0. A host
with neither binary still runs uncapped, but now says so on stderr, where the
scheduler's own log keeps it, instead of dropping the budget in silence. Linux
is unaffected: timeout was always found there.
One known consequence of the cap being live on macOS, surfaced by the pre-ship
review and deliberately left as-is: a polish run the cap kills exits 124, and if
its partial log happens to carry a provider-limit word (quota, overloaded),
this runner's rate-limit branch reports EX_TEMPFAIL 75 — "try again later" —
rather than a timeout. The autoloop driver distinguishes 124 explicitly; this one
does not yet. Pre-existing logic with a bounded false-positive surface (the grep
runs only on failed runs), newly reachable here, and a fix would be its own
change rather than a line in a release.
update-notify.sh joins the bash-3.2 CI leg. It is a SessionStart hook, so
on a stock macOS box it is bash 3.2 that runs it in every real session — and the
only thing asserting it could was a comment in its own header, while README said
outright that the test-bash32 job did not cover it. That job now runs six
suites and syntax-checks six scripts. Verified under a real 3.2.57 before
wiring, via CLAUDE.md's docker recipe (extended to the same six suites): all six
green, test-update-notify 26 passed / 0 failed, and the six-script bash -n
list parses. musl is not BSD, so the macOS cell is the one the CI leg adds.
tests/test-update-notify.sh also stops resolving bash from PATH when it runs
the hook and uses $BASH, the interpreter running the suite: under the 3.2 leg a
5.x homebrew bash that happened to be installed would otherwise have run the
hook, and the leg would have reported a 3.2 verdict it never tested.
Evidence for the polish fix, in the order it happened:
tests/test-unattended-polish.sh 30 → 39 assertions. Run against the pre-fix
driver, exactly the arms carrying the fix fail and everything else passes —
35 passed / 2 failed for the gtimeout arm and the stderr-warning arm, and later
38 / 1 for the rolling-log assertion the pre-ship review added. Post-fix: 39 / 0.
The both-installed arm passed throughout, which is what proves the harness rather
than the fix. Both absent-binary arms run the driver under a minimal bin dir of
symlinks to exactly what it and the stub exec, because no real PATH can be made
to lack timeout on demand; each prerequisite symlink is asserted, so a missing
one cannot masquerade as a driver bug.
Docs: the README Requirements table drops its "Known, not yet fixed" admission,
and its intro names the guard-weakening rows correctly — rows 1-4, not "1-3 and
5", which counted curl (a missing notice, not a guard) and skipped the polish
timeout row.
Live-install smoke (RELEASING.md §1, against this release's content): PASS on
Claude Code 2.1.278, via a genuine claude plugin marketplace add sdsrss/loop_eng
claude plugin installinto an isolatedCLAUDE_CONFIG_DIR. A GitHub source,
so the copy that enforced is the version-pinned
plugins/cache/loop-eng/loop-eng/0.14.0/one and not the marketplace clone —
both existed, andarm-contractprintedarmed fromthat cache path. No
source-type disclosure is owed this time: 0.14.0 was onmainbefore the smoke
ran, which is what makesmarketplace add owner/repoinstall the release's own
content.
Machine-verified rather than model-reported, by instrumenting the live cached
hooks. Step 4: DENY-FIRED … root=<the real cache path> — not the
<loop-eng plugin root> placeholder, so CLAUDE_PLUGIN_ROOT reaches hook
processes — and .loop/evidence/smoke.log did not land under
--permission-mode bypassPermissions. Step 5: BLOCK-exit n=0..2 then
CEILING-RELEASE count=3 over a generated_by: run-contract.sh ledger reading
all_green: false with the red criterion false, while .loop/evidence/red.log
was written by the runner — the same directory the model had been denied a moment
earlier, which is the whole invariant in two steps. Step 6: a full
/loop-eng:autoloop round reached all_green: true on both criteria, hello.txt
held hi, and .loop/active + .loop/criteria.sha256 were removed by the gate
rather than by the model. Reachable only if ${CLAUDE_PLUGIN_ROOT} expanded
inside the command markdown. That session's own closing summary asserted
.loop/active was "still armed"; the disk said it was gone. The disk is the
authority here, which is the point of the plugin.
Pre-ship review (independent reviewer, fresh context, over dcf2745..9b9f62f):
every numeric claim above re-measured, including under a real 3.2.57; no blocking
finding; six accepted repairs. Two were load-bearing. The new UNBOUNDED warning
went to stderr only, and this script's own cron example ends >/dev/null 2>&1 —
so the warning was discarded by the very invocation it is written for, leaving a
plain exit=0 in .loop/unattended.log for an uncapped run, and making the
"where the scheduler's log keeps it" line above false for anything but the systemd
path. It is now tee'd into the rolling log, like the dirty-tree refusal. And the
test-bash32 leg's "Prove /bin/bash is stock 3.2" step printed the version
without asserting it: a runner image that ever ships a newer /bin/bash would
have kept that leg green while testing the wrong interpreter — the same
silent-disarm shape this release's other half exists to close. It now fails the
job unless BASH_VERSINFO[0] is 3. Four smaller ones: README's "each says so"
now excludes arm-contract.sh's advisory red-check (which really does just run
unbounded), the env-var table stops crediting timeout alone for the budget, the
both-installed arm asserts that exactly one wrapper ran rather than trusting a
substring on an append-only record, and the minimal-bin-dir comment names
/usr/bin/env as the one prerequisite no symlink can cover.
v0.13.0
New-user lifecycle QA: install → use → update → self-heal → uninstall, driven
end to end against a genuine claude plugin marketplace add sdsrss/loop_eng
install into an isolated CLAUDE_CONFIG_DIR on Claude Code 2.1.278. The
enforcement layer passed every leg on the real artifact — evidence-gate denied
a Write to .loop/evidence/ with CLAUDE_PLUGIN_ROOT resolved to the cache
path, the stop-gate blocked a red contract and machine-wrote
"generated_by": "run-contract.sh" / "all_green": false, /autoloop armed
via ${CLAUDE_PLUGIN_ROOT} and reached ALL GREEN, the hash-lock caught a
post-arm rewrite (exit 77), and a runner deleted from the cache produced the
fail-closed block that names /plugin update loop-eng. What the sweep found
was on the edges: one packaging defect, three places where a real environment
dependency lived only in a code comment, one quiet corner of the hash-lock, and
two release-blocking facts that were checklist lines rather than tests. Test
suite 411 → 456 assertions.
Release smoke (RELEASING.md §1, re-run against this release's content at
0.13.0 after the version bump; the earlier 0.12.2 run is superseded rather than
carried over, because a smoke that names a version has to have run on it): PASS
on Claude Code 2.1.278, machine-verified rather than model-reported. Step 4 —
the model's Write to .loop/evidence/smoke.log was DENIED, the file did not
land under --permission-mode bypassPermissions, and an instrumented deny()
logged a real root= path rather than the <loop-eng plugin root> placeholder,
so CLAUDE_PLUGIN_ROOT reaches hook processes. Step 5 — a false criterion
blocked the stop (BLOCK n=1) and run-contract.sh machine-wrote
"all_green": false. Step 6 — a full /loop-eng:autoloop round reached
"all_green": true on two criteria, hello.txt held hi, and .loop/active
and .loop/criteria.sha256 were removed by the gate rather than by the model,
which is reachable only if ${CLAUDE_PLUGIN_ROOT} expanded inside the command
markdown.
Source-type disclosure, owed by the rule this release adds to RELEASING.md §1:
the marketplace was added by local path, because 0.13.0 was not yet pushed and
marketplace add owner/repo can only take the default branch. The instrumented
markers named the source copy, confirming it enforced while the version-pinned
plugins/cache/ copy did not — exactly what that new rule predicts, verified on
its first two uses. The GitHub-source path, which is the one real users get, is
re-smoked against the released tag per §3 Post-ship.
Pre-ship review: an independent reviewer with no authoring context returned
SHIP with no BLOCKER, having driven every fail-closed exit in a sandbox (78
missing criteria, 77 post-arm tamper, 77 locked-with-no-SHA-tool, 73 unwritable
.loop and .loop/evidence, plus the stop-gate's block-ceiling, missing-runner,
timeout-124 and green-disarm paths) and mutation-tested both new suites. It also
raised one HIGH and six MEDIUM/LOW findings, all fixed above or recorded as
known. Three of those were absolute claims the author asserted without checking
what else could produce the state they named — the reason author ≠ reviewer is
a rule here and not a courtesy.
fix: the two timer scripts shipped non-executable. install-timer.sh and
uninstall-timer.sh were recorded in git as 100644, while README documents
both as bare-path commands (skills/loop-eng/scripts/install-timer.sh <polish| autoloop> <repo>). A marketplace install materializes the tree with its
recorded modes, so the first line a new user pasted answered Permission denied — reproduced in the installed cache copy, not just the repo. Their two
siblings in the same directory, unattended-polish.sh and
unattended-autoloop.sh, were already 100755, which is why the gap survived:
every test in the suite invokes these scripts as bash <path>, a form that
works at any mode, so nothing exercised the documented one. Now 100755.
test: tests/test-packaging.sh (new, 12 assertions) closes that blind spot
by asserting the git-index mode of every script README invokes bare-path. The
candidate list is derived from README rather than written down — a runner
documented tomorrow is covered tomorrow — and the scan fails closed if its
pattern ever matches nothing, so the suite cannot go green while checking zero
files. It also pins the converse: hooks.json spawns every hook through
bash "<path>", so hook modes are deliberately not part of the contract.
docs: a Requirements table in README. jq/python3, a SHA-256 tool,
timeout/gtimeout, curl, systemctl, and the bash ≥ 4.4 floor were each
probed at run time and documented only in the script that probes them. Two of
those absences silently weaken a guard, which is exactly the class that should
not live in a comment. Each row states what actually degrades; every claim was
grep-verified against the probing script.
test: the parser-less evidence-gate is now pinned (+2 assertions). With
neither jq nor python3 the gate fails open — deliberate, since a PreToolUse
hook must never brick a session, but it was the one environment where the gate
looks installed and enforces nothing, and no test covered it. Both halves are
now asserted: the exit code stays 0, and the stderr warning that is a human's
only signal stays present. README states the consequence and its bound,
measured rather than reasoned: on a parser-less box a hand-forged
{"all_green": true} in .loop/results.json was overwritten by
run-contract.sh on the next stop attempt and the stop was still blocked
(exit 2). The evidence-gate is defense-in-depth; the stop-gate is load-bearing
and needs no parser.
docs: two traps in RELEASING.md. (1) The pre-flight now validates the
plugin manifest by path — given . the validator finds marketplace.json
first and reports "contents": [], a green that checked no command, agent, or
skill; the one expected --strict warning (root CLAUDE.md) is named so any
other is a blocker. (2) §1 now requires adding the marketplace by its GitHub
source: a directory source runs the plugin from the source directory,
leaves plugins/marketplaces/ empty and never executes the version-pinned
plugins/cache/ copy that every path in steps 3–4 points at. Confirmed by
running the same smoke once per source type with a marker in deny() in both
copies. Instrumenting the cache under a directory source yields an empty log
that reads exactly like "the hook never fired" — the fourth instance of that
family in these two steps.
fix(run-contract): a missing hash-lock is no longer silent. The integrity
check ran under [ -f "$ACTIVE" ] && [ -f "$SHA_LOCK" ], so a missing
criteria.sha256 skipped it entirely and a lockless run was indistinguishable
from a locked one — the corner where "weakening an armed contract can never
pass silently" stopped being true. Armed, no lock, and a SHA-256 tool present
now warns on stderr and stamps "contract_lock": "absent" into
results.json.
It reports the state, not a cause, and that distinction is this entry's own
correction: the first draft asserted that arm-contract.sh "drops the lock in
exactly one case" and told the reader to re-arm through it. Both halves were
wrong. arm-contract.sh omits the lock on two paths (no hashing tool, and no
criteria.tsv at arm time), and commands/autoloop.md documents a last-resort
arm that is a bare touch .loop/active — on which the warning fired every run
and prescribed re-running a script that path exists because it is unavailable.
Caught by the pre-ship reviewer, not by the author. The message now states only
what the code can observe: the tamper check did not run.
Deliberately a warning, not a refusal — every route to this state is
legitimate, and failing closed would strand a live loop whose only exit is
deleting .loop/active, trading a documented residual for a new way to lose
work. The ledger carries it because a green contract lets the stop-gate exit 0,
which discards hook output. Every arm of the branch is tested (+13 assertions),
including the two that must stay silent: a machine with no hashing tool, and
the documented touch .loop/active fallback, which must warn without
misdiagnosing.
fix(unattended): the bash ≥ 4.4 floor is checked, not just stated. Both
drivers carried "Requires bash >= 4.4" as a header comment and nothing else, so
on stock macOS bash 3.2 they STARTED, did real work, and only then died on the
first empty-array expansion under set -u — the worst shape for an unattended
writer, which for unattended-autoloop.sh may already have let a session
commit. They now refuse up front with exit 78 (EX_CONFIG) and a message naming
the requirement. Verified on real bash 3.2.57 via the docker recipe in
CLAUDE.md: both exit 78. A separate BASH_VERSION check runs first and stays
its own statement, because a non-bash shell dies on the array subscript in the
version test with a bare "Bad substitution" — the :-0 default never applies,
since the failure is in the subscript syntax rather than the value. Found by
the pre-ship reviewer, who noticed the README row this batch added claimed a
guard that did not exist.
docs: the Requirements table said things that were not so. Same review. The
timeout row omitted the unattended drivers; systemctl omitted
uninstall-timer.sh; there was no row at all for the claude CLI, which
install-timer.sh hard-requires — a stronger dependency than three of the rows
that were listed. The table now also records an asymmetry it surfaced:
unattended-polish.sh probes only timeout and never falls back to
gtimeout, unlike its three siblings, so on macOS-with-coreutils a scheduled
polish runs uncapped while autoloop does not. Pre-existing, documented here,
not fixed in this release. The "(CI-tested)" claim is narrowed to the four
scripts test-bash32 actually covers — update-notify.sh is a registered hook
and ...