Derive the round's state from the session file, name the steps, and test the pure core

This commit is contained in:
2026-09-24 20:21:06 +02:00
parent 8f647f8596
commit 839804f47e
8 changed files with 390 additions and 177 deletions
+6 -4
View File
@@ -5,10 +5,12 @@
*
!.gitignore
!AGENTS.md
!CLAUDE.md
!README.md
!settings.json
!statusline.sh
!todo.md
!agent-shared/
!agent-shared/**
@@ -16,10 +18,10 @@
!agents/*.md
!bin/
!bin/*
!docs/
!docs/*.md
!principles/
!principles/*.md
!skills/
!skills/comprehension-panel/
!skills/comprehension-panel/**
!skills/larv-review/
!skills/larv-review/**
!skills/*/
!skills/*/**
+8
View File
@@ -0,0 +1,8 @@
# Working here
Decisions live in `docs/decisions.md`:
- loop-claude: a judge decides interrupts, not the worker's self-report
- loop-claude: one session per project, at a fixed id
- loop-claude: the trust file is rewritten before a handoff
- bin/: host python, no container
+12 -4
View File
@@ -1,12 +1,13 @@
# Claude Code configuration
My personal `~/.claude`, version controlled. Instructions, agents, skills, principles and settings.
My personal `~/.claude`, version controlled. Instructions, agents, skills, principles, settings and the tools in `bin/`.
## Goals
1. Share this configuration between my computers.
2. Keep it backed up.
3. Leak nothing — no credentials, no session transcripts, no memory.
4. Run work chunks unattended, interrupting me only when a decision is mine.
## Audience
@@ -14,13 +15,20 @@ Me, on my own machines. Private repo, nobody else depends on it.
## Install
Link `bin/` onto `PATH`: `ln -s ~/.claude/bin/loop-claude ~/.local/bin/loop-claude`.
Link the tools onto `PATH`: `ln -s ~/.claude/bin/loop-claude ~/.local/bin/loop-claude`, and the same for `claude-instances`.
## Tools
- `loop-claude <task>` runs a project's next chunk round after round; `loop-claude --help` states its contract.
- `claude-instances` redraws a table of the running claude sessions by project.
Test: `python3 -m unittest bin/test_loop_claude.py`
## Tracking a new file
`.gitignore` is an allowlist: everything is ignored, and a file is tracked only by being named. Add it as a negation, with its parent directories un-ignored too, then confirm with `git check-ignore -v <path>`:
```
!commands/
!commands/*.md
!docs/
!docs/*.md
```
+74
View File
@@ -0,0 +1,74 @@
#!/usr/bin/env python3
import os
import sys
import time
CODE = os.path.expanduser("~/code")
HOME = os.path.expanduser("~")
INTERVAL = float(os.environ.get("INTERVAL", "2"))
PLUMBING = ("--bg-pty-host", "--bg-spare", "--json-path", "--spawned-by")
def processes():
found = {}
for pid in os.listdir("/proc"):
if not pid.isdigit():
continue
try:
argv = open(f"/proc/{pid}/cmdline", "rb").read().decode("utf-8", "replace").split("\0")[:-1]
cwd = os.readlink(f"/proc/{pid}/cwd")
ppid = next(int(line.split()[1]) for line in open(f"/proc/{pid}/status") if line.startswith("PPid:"))
except (OSError, StopIteration, ValueError):
continue
if argv:
found[int(pid)] = (argv, ppid, cwd.removesuffix(" (deleted)"))
return found
def shown(cwd):
if cwd == CODE:
return "code"
if cwd.startswith(f"{CODE}/"):
return os.path.relpath(cwd, CODE)
return cwd.replace(HOME, "~", 1)
def rows(found):
wrappers = set()
for pid, (argv, ppid, _) in found.items():
if not os.path.basename(argv[0]).startswith("claude") or any(flag in argv for flag in PLUMBING):
continue
parent = found.get(ppid)
if parent and os.path.basename(parent[0][0]).startswith("python"):
wrappers.add(ppid)
listed, claimed = [], set()
for pid in wrappers:
status = "Auto"
for child, (argv, ppid, _) in found.items():
if ppid == pid and os.path.basename(argv[0]).startswith("claude"):
claimed.add(child)
if "--resume" in argv:
status = "Inter"
listed.append((status, shown(found[pid][2])))
for pid, (argv, _, cwd) in found.items():
if pid in claimed or pid in wrappers:
continue
if not os.path.basename(argv[0]).startswith("claude"):
continue
if any(flag in argv for flag in PLUMBING):
continue
listed.append(("Other", shown(cwd)))
return sorted(listed, key=lambda row: (row[1], row[0]))
try:
while True:
listed = rows(processes())
width = max([len(path) for _, path in listed] + [4])
out = [f"{'STATUS':<6} {'PATH':<{width}}", f"{'-' * 6} {'-' * width}"]
out += [f"{status:<6} {path:<{width}}" for status, path in listed] or ["(none running)"]
sys.stdout.write("\x1b[H\x1b[2J" + "\n".join(out) + "\n")
sys.stdout.flush()
time.sleep(INTERVAL)
except KeyboardInterrupt:
pass
+187 -169
View File
@@ -1,4 +1,22 @@
#!/usr/bin/env python3
"""Run a task as headless claude rounds; a judge stops the loop only when a decision is the human's.
usage: loop-claude <task>
Run it in a project checkout whose README.md has ## Goals and ## Audience. Each round a worker runs
the task; a judge then reads the transcript against the README. A question only the human can answer
opens `claude --resume` on the terminal. An unfinished chunk resumes the same session next round; a
finished one starts a fresh session. Rounds continue until Ctrl-C.
Exit 1: the README gate blocks, or claude fails three rounds running. Exit 2: the human is needed and
no terminal is attached, or the handoff ended without them typing anything.
Each project has one session, "A ~/code/<path> auto-mode", at an id derived from that name; it is
resumed while present and deleted when the chunk finishes. Its transcript is archived under
$AUTO_MODE_TRANSCRIPTS (default ~/.claude/auto-mode-transcripts/<path>/) whenever the human is asked
and when the chunk finishes. JUDGE_MODEL and WORKER_MODEL override the models. A change to this
file takes effect at the next round boundary.
"""
import glob
import json
import os
@@ -9,11 +27,32 @@ import uuid
ARCHIVE = os.path.expanduser(os.environ.get("AUTO_MODE_TRANSCRIPTS", "~/.claude/auto-mode-transcripts"))
JUDGE_MODEL = os.environ.get("JUDGE_MODEL", "claude-opus-5-5")
ROUND = "LOOP_CLAUDE_ROUND"
SLOT_NAMESPACE = uuid.UUID("64fb586b-d926-4bb3-a44c-c903e86d3eec")
SOURCE = open(__file__, encoding="utf-8").read()
STATE = "LOOP_CLAUDE_STATE"
WORKER_MODEL = os.environ.get("WORKER_MODEL", "claude-opus-5-5")
JUDGE_RULES = (
"Decide whether the human must now be interrupted. ask=true when any of these appear:\n"
"- the agent asks the human anything, seeks approval, or says a decision is the human's\n"
"- it carried on under an assumption that decides the deliverable and that the human could "
"reasonably reject; a caveat about transient state it then handled is not one\n"
"- it is blocked on something only the human can supply: a credential, a version bump, a choice "
"outside the repo\n"
"- it flags that the goals, the plan or the task itself is unclear, missing or in need of change\n"
"- it chose between alternatives the README text does not discriminate between - it does not "
"rule the rejected one out - and the choice materially changes the deliverable\n"
"ask=false otherwise. A sensible preference is not a derivation. Bookkeeping the agent settled "
"silently - what to document, wording, where a note goes - is not on its own a reason to "
"interrupt. The human may have replied inside the transcript: judge only what is still open, "
"never a question they already answered there.\n"
"The question must be one the agent itself raised. Never construct a question from facts the agent "
"stated. When ask=true, quote the agent's own wording where it already framed the question.\n"
"finished=true when the chunk is complete: merged, or nothing remains that the agent could do on "
"its own. finished=false when work remains that a further run can continue: an open PR, a review "
"not yet run, CI not yet reported."
)
JUDGE_SCHEMA = {
"properties": {
"ask": {"type": "boolean"},
@@ -26,41 +65,9 @@ JUDGE_SCHEMA = {
}
def claude(args):
proc = subprocess.run(["claude", *args], capture_output=True, text=True)
if proc.returncode != 0:
sys.exit(proc.stderr.strip() or "claude failed")
return json.loads(proc.stdout)
def work(args):
proc = subprocess.Popen(["claude", *args], stdout=subprocess.PIPE, text=True)
done = {}
for line in proc.stdout:
try:
event = json.loads(line)
except ValueError:
continue
if event.get("type") == "result":
done = event
elif event.get("type") == "assistant":
for part in event["message"]["content"]:
if part["type"] == "text" and part["text"].strip():
print(part["text"], flush=True)
elif part["type"] == "tool_use":
print(f"· {part['name']} {json.dumps(part['input'])[:160]}", flush=True)
if proc.wait() != 0 or not done:
sys.exit("claude failed")
return done
def sections():
try:
lines = open("README.md", encoding="utf-8").read().splitlines()
except OSError:
return {}
def sections(text):
found, current = {}, None
for line in lines:
for line in text.splitlines():
if line.startswith("## "):
current = line.strip()[3:]
found[current] = []
@@ -69,6 +76,16 @@ def sections():
return {name: "\n".join(body) for name, body in found.items() if body}
def premises():
try:
found = sections(open("README.md", encoding="utf-8").read())
except OSError:
found = {}
if not found.get("Goals") or not found.get("Audience"):
sys.exit("README.md needs ## Goals and ## Audience - the gate blocks.")
return f"## Goals\n{found['Goals']}\n\n## Audience\n{found['Audience']}"
def project_path():
root = os.path.expanduser("~/code")
cwd = os.getcwd()
@@ -89,14 +106,12 @@ def session_name():
return f"A {cwd} auto-mode"
def slot_file(session_id):
hit = glob.glob(os.path.expanduser(f"~/.claude/projects/*/{session_id}.jsonl"))
def session_file(slot):
hit = glob.glob(os.path.expanduser(f"~/.claude/projects/*/{slot}.jsonl"))
return hit[0] if hit else ""
def entries(path):
if not path:
return
for raw in open(path, encoding="utf-8"):
try:
entry = json.loads(raw)
@@ -106,36 +121,9 @@ def entries(path):
yield entry
def clear_slot(name, slot):
path = slot_file(slot)
if not path:
return True
for entry in entries(path):
if "agentName" in entry:
if entry["agentName"] != name:
return False
archive(path, "Archived when a later run cleared the slot.")
os.remove(path)
return True
return False
def typed(path):
spoken = 0
for entry in entries(path):
if entry.get("type") != "user":
continue
content = entry.get("message", {}).get("content")
if isinstance(content, str):
spoken += 1
elif isinstance(content, list) and not any(part.get("type") == "tool_result" for part in content if isinstance(part, dict)):
spoken += 1
return spoken
def render(path):
def render(entries):
said = []
for entry in entries(path):
for entry in entries:
if entry.get("type") != "assistant":
continue
for part in entry.get("message", {}).get("content", []):
@@ -148,21 +136,30 @@ def render(path):
return "\n\n".join(said)
def human_turns(entries):
spoken = 0
for entry in entries:
if entry.get("type") != "user":
continue
content = entry.get("message", {}).get("content")
if isinstance(content, str):
spoken += 1
elif isinstance(content, list) and not any(part.get("type") == "tool_result" for part in content if isinstance(part, dict)):
spoken += 1
return spoken
def archive(path, note):
if not path:
return ""
folder = os.path.join(ARCHIVE, project_path())
try:
stamp = time.strftime("%Y-%m-%dT%H-%M-%S", time.localtime(os.path.getmtime(path)))
stamp = time.strftime("%Y-%m-%dT%H-%M-%SZ", time.gmtime(os.path.getmtime(path)))
os.makedirs(folder, exist_ok=True)
dest = os.path.join(folder, f"{stamp}.md")
if os.path.exists(dest):
return dest
open(dest, "w", encoding="utf-8").write(f"# {stamp} {project_path()}\n\n{note}\n\n{render(path)}\n")
if not os.path.exists(dest):
open(dest, "w", encoding="utf-8").write(f"# {stamp} {project_path()}\n\n{note}\n\n{render(entries(path))}\n")
print(f"transcript: {dest}", file=sys.stderr)
except OSError as failure:
print(f"could not archive the transcript: {failure}", file=sys.stderr)
return ""
return dest
def checkouts():
@@ -174,15 +171,16 @@ def checkouts():
def trust(paths):
# No CLI flag skips the trust dialog, and the interactive resume would stall on it in every worktree the round created.
config = os.path.expanduser("~/.claude.json")
try:
data = json.load(open(config, encoding="utf-8"))
except (OSError, ValueError):
return []
return
projects = data.setdefault("projects", {})
granted = [path for path in paths if not projects.setdefault(path, {}).get("hasTrustDialogAccepted")]
if not granted:
return []
return
for path in granted:
projects[path]["hasTrustDialogAccepted"] = True
staged = f"{config}.loop-claude"
@@ -192,49 +190,107 @@ def trust(paths):
os.replace(staged, config)
except OSError as failure:
print(f"could not record trust: {failure}", file=sys.stderr)
return []
return granted
return
print("trusted for the handoff: " + ", ".join(granted), file=sys.stderr)
def interrupt(task, premises, work):
verdict = claude([
"-p",
def worker_args(task, name, slot, resuming):
if resuming:
start = ["-p", "Continue the task; the previous run stopped before it was finished.", "--resume", str(slot)]
else:
start = ["-p", f"{task}\n\nContinue any open draft PR or worktree for the item before creating a new one.", "--name", name, "--session-id", str(slot)]
return [
*start,
"--output-format", "stream-json",
"--permission-mode", "bypassPermissions",
"--verbose",
*(["--model", WORKER_MODEL] if WORKER_MODEL else []),
]
def run_worker(args):
proc = subprocess.Popen(["claude", *args], stdout=subprocess.PIPE, text=True)
done = {}
for line in proc.stdout:
try:
event = json.loads(line)
except ValueError:
continue
if event.get("type") == "result":
done = event
elif event.get("type") == "assistant":
for part in event["message"]["content"]:
if part["type"] == "text" and part["text"].strip():
print(part["text"], flush=True)
elif part["type"] == "tool_use":
print(f"· {part['name']} {json.dumps(part['input'])[:160]}", flush=True)
return done if proc.wait() == 0 else {}
def judge_prompt(task, premises, transcript):
return (
f"README.md, verbatim:\n{premises}\n\n"
f"The task an agent was given:\n{task}\n\n"
f"What the agent then did and said:\n{work[:40000]}\n\n"
"Decide whether the human must now be interrupted. ask=true when any of these appear:\n"
"- the agent asks the human anything, seeks approval, or says a decision is the human's\n"
"- it carried on under an assumption that decides the deliverable and that the human could "
"reasonably reject; a caveat about transient state it then handled is not one\n"
"- it is blocked on something only the human can supply: a credential, a version bump, a choice "
"outside the repo\n"
"- it flags that the goals, the plan or the task itself is unclear, missing or in need of change\n"
"- it chose between alternatives the README text does not discriminate between - it does not "
"rule the rejected one out - and the choice materially changes the deliverable\n"
"ask=false otherwise. A sensible preference is not a derivation. Bookkeeping the agent settled "
"silently - what to document, wording, where a note goes - is not on its own a reason to "
"interrupt. The human may have replied inside the transcript: judge only what is still open, "
"never a question they already answered there.\n"
"The question must be one the agent itself raised. Never construct a question from facts the agent "
"stated. When ask=true, quote the agent's own wording where it already framed the question.\n"
"finished=true when the chunk is complete: merged, or nothing remains that the agent could do on "
"its own. finished=false when work remains that a further run can continue: an open PR, a review "
"not yet run, CI not yet reported.",
f"What the agent then did and said, latest last:\n{transcript[-40000:]}\n\n"
f"{JUDGE_RULES}"
)
def grounded(verdict, transcript):
return not verdict["ask"] or verdict["evidence"] in transcript
def judge(task, premises, transcript):
args = [
"-p", judge_prompt(task, premises, transcript),
"--json-schema", json.dumps(JUDGE_SCHEMA),
"--model", JUDGE_MODEL,
"--no-session-persistence",
"--output-format", "json",
"--permission-mode", "bypassPermissions",
"--tools", "",
])
verdict = verdict["structured_output"]
if verdict["ask"] and verdict["evidence"] not in work:
print("judge quoted nothing in the transcript - treating as done", file=sys.stderr)
verdict["ask"] = False
]
for attempt in range(2):
proc = subprocess.run(["claude", *args], capture_output=True, text=True)
if proc.returncode != 0:
sys.exit(proc.stderr.strip() or "the judge failed")
verdict = json.loads(proc.stdout)["structured_output"]
if grounded(verdict, transcript):
return verdict
print("the judge quoted nothing in the transcript twice - interrupting anyway", file=sys.stderr)
return verdict
def reload(state):
def handoff(slot, path, question):
print(f"\n{question}", file=sys.stderr)
if not sys.stdin.isatty():
return False
trust(checkouts())
before = human_turns(entries(path))
subprocess.run(["claude", "--permission-mode", "bypassPermissions", "--resume", str(slot)])
return human_turns(entries(path)) > before
def run_round(task, given, name, slot):
worked = run_worker(worker_args(task, name, slot, resuming=bool(session_file(slot))))
if not worked:
return False
path = session_file(slot)
if not path:
sys.exit(f"claude left no transcript for session {slot}")
verdict = judge(task, given, render(entries(path)))
while verdict["ask"]:
archive(path, f"Task: {task}\n\nVerdict: needs input\n\n{verdict['question']}")
if not handoff(slot, path, verdict["question"]):
sys.exit(2)
verdict = judge(task, given, render(entries(path)))
if verdict["finished"]:
archive(path, f"Task: {task}\n\nVerdict: finished")
os.remove(path)
return True
def reload_if_edited(round_number):
try:
source = open(__file__, encoding="utf-8").read()
compile(source, __file__, "exec")
@@ -243,70 +299,32 @@ def reload(state):
return
if source == SOURCE:
return
os.environ[STATE] = json.dumps(state)
os.environ[ROUND] = str(round_number)
os.execv(sys.executable, [sys.executable, __file__, *sys.argv[1:]])
task = " ".join(sys.argv[1:])
if not task:
sys.exit("usage: loop-claude <task>")
state = json.loads(os.environ.pop(STATE, "{}"))
round_number = state.get("round", 0)
resume = state.get("resume", "")
while True:
reload({"round": round_number, "resume": resume})
round_number += 1
found = sections()
if not found.get("Goals") or not found.get("Audience"):
sys.exit("README.md needs ## Goals and ## Audience - the gate blocks.")
premises = f"## Goals\n{found['Goals']}\n\n## Audience\n{found['Audience']}"
name = session_name()
print(f"\n=== round {round_number} ===", flush=True)
if resume:
start = ["-p", "Continue the task; the previous run stopped before it was finished.", "--resume", resume]
else:
slot = uuid.uuid5(SLOT_NAMESPACE, name)
sticky = clear_slot(name, slot)
if not sticky:
print(f"session {slot} is not this tool's - running without the slot", file=sys.stderr)
start = [
"-p", f"{task}\n\nContinue any open draft PR or worktree for the item before creating a new one.",
"--name", name,
*(["--session-id", str(slot)] if sticky else []),
]
worked = work([
*start,
"--output-format", "stream-json",
"--permission-mode", "bypassPermissions",
"--verbose",
*(["--model", WORKER_MODEL] if WORKER_MODEL else []),
])
path = slot_file(worked["session_id"])
verdict = interrupt(task, premises, render(path) or worked["result"])
def main():
task = " ".join(sys.argv[1:])
if task in ("", "-h", "--help"):
print(__doc__.strip())
sys.exit(0 if task else 1)
round_number = int(os.environ.pop(ROUND, 0))
failures = 0
while True:
kept = archive(path, f"Task: {task}\n\nVerdict: {'needs input' if verdict['ask'] else 'finished' if verdict['finished'] else 'continues'}\n\n{verdict['question']}".rstrip())
if kept:
print(f"transcript: {kept}", file=sys.stderr)
if not verdict["ask"]:
break
reload_if_edited(round_number)
round_number += 1
given = premises()
name = session_name()
print(f"\n=== round {round_number} ===", flush=True)
if run_round(task, given, name, uuid.uuid5(SLOT_NAMESPACE, name)):
failures = 0
continue
failures += 1
if failures == 3:
sys.exit("claude failed three rounds running")
print("claude failed - retrying in a minute", file=sys.stderr)
time.sleep(60)
print(f"\n{verdict['question']}", file=sys.stderr)
if not sys.stdin.isatty():
sys.exit(2)
granted = trust(checkouts())
if granted:
print("trusted for the handoff: " + ", ".join(granted), file=sys.stderr)
answered = typed(path)
subprocess.run(["claude", "--permission-mode", "bypassPermissions", "--resume", worked["session_id"]])
path = slot_file(worked["session_id"])
if typed(path) <= answered:
sys.exit(2)
verdict = interrupt(task, premises, render(path))
resume = "" if verdict["finished"] else worked["session_id"]
if __name__ == "__main__":
main()
+76
View File
@@ -0,0 +1,76 @@
import importlib.machinery
import importlib.util
import pathlib
import unittest
LOADER = importlib.machinery.SourceFileLoader("loop_claude", str(pathlib.Path(__file__).with_name("loop-claude")))
SPEC = importlib.util.spec_from_loader("loop_claude", LOADER)
loop = importlib.util.module_from_spec(SPEC)
LOADER.exec_module(loop)
def assistant(*parts):
return {"type": "assistant", "message": {"content": list(parts)}}
def human(content):
return {"type": "user", "message": {"content": content}}
class Sections(unittest.TestCase):
def test_keeps_only_headed_sections_with_a_body(self):
text = "# Title\n\nintro\n\n## Goals\n\n1. one\n2. two\n\n## Empty\n\n## Audience\nme\n"
self.assertEqual(loop.sections(text), {"Goals": "1. one\n2. two", "Audience": "me"})
class Render(unittest.TestCase):
def test_joins_assistant_text_and_tool_calls_and_skips_the_rest(self):
said = loop.render([
human("do it"),
assistant({"type": "text", "text": "Starting."}, {"type": "tool_use", "name": "Bash", "input": {"command": "ls"}}),
assistant({"type": "text", "text": " "}),
])
self.assertEqual(said, 'Starting.\n\n[tool Bash] {"command": "ls"}')
class HumanTurns(unittest.TestCase):
def test_counts_typed_turns_and_not_tool_results(self):
self.assertEqual(loop.human_turns([
human("typed"),
human([{"type": "text", "text": "typed as a block"}]),
human([{"type": "tool_result", "content": "not typed"}]),
assistant({"type": "text", "text": "said"}),
]), 2)
class WorkerArgs(unittest.TestCase):
def test_a_fresh_round_names_the_session_and_asks_to_continue_open_work(self):
args = loop.worker_args("the task", "A name", "slot-id", resuming=False)
self.assertIn("--session-id", args)
self.assertEqual(args[args.index("--name") + 1], "A name")
self.assertTrue(args[1].startswith("the task\n\nContinue any open draft PR"))
def test_a_resumed_round_reuses_the_session(self):
args = loop.worker_args("paint the fence", "A name", "slot-id", resuming=True)
self.assertEqual(args[args.index("--resume") + 1], "slot-id")
self.assertNotIn("--name", args)
self.assertNotIn("paint the fence", args[1])
class JudgePrompt(unittest.TestCase):
def test_hands_the_judge_the_tail_of_a_long_transcript(self):
prompt = loop.judge_prompt("task", "## Goals\n1. g", "early " * 20000 + "LATE")
self.assertIn("LATE", prompt)
self.assertLess(prompt.count("early"), 20000)
self.assertTrue(prompt.endswith(loop.JUDGE_RULES))
class Grounded(unittest.TestCase):
def test_an_interrupt_must_quote_the_transcript(self):
self.assertTrue(loop.grounded({"ask": False, "evidence": ""}, "anything"))
self.assertTrue(loop.grounded({"ask": True, "evidence": "Needs you: x"}, "so.\n\nNeeds you: x\n"))
self.assertFalse(loop.grounded({"ask": True, "evidence": "invented"}, "the transcript"))
if __name__ == "__main__":
unittest.main()
+17
View File
@@ -0,0 +1,17 @@
# Decisions
## loop-claude: a judge decides interrupts, not the worker's self-report
2026-09-21, lilleman. Serves goal 4. Asked to name the goal behind each choice, the worker cites a real goal for a choice that goal does not settle, and under-reports its own decisions; the judge's bar is whether the README discriminates between the alternatives. Valid while the worker's self-report stays unreliable.
## loop-claude: one session per project, at a fixed id
2026-09-21, lilleman. Serves goal 4. The id is uuid5 of the session name under the script's own namespace, so the session picker holds one entry per project and any transcript under that id is the script's own: resumed while present, deleted when the chunk finishes. Valid while the picker lists sessions by id.
## loop-claude: the trust file is rewritten before a handoff
2026-09-21, lilleman; the lost-write risk accepted 2026-09-24 by larv-review. Serves goal 4. No CLI flag skips the trust dialog, so `~/.claude.json` gets `hasTrustDialogAccepted` for every checkout before `claude --resume`. A write by another claude inside that read-modify-write window is lost. Valid while no flag skips the dialog.
## bin/: host python, no container
2026-09-24, larv-review. Serves goals 1 and 4. The tools drive the host's claude CLI and read the host's session files, which a container cannot see; the tests run the same way. Valid while claude runs on the host.
+10
View File
@@ -0,0 +1,10 @@
# todo
## 0.1.0
- Delete `agent-shared/`: no agent carries its markers, and its memory system contradicts the agents' own no-private-memory rule.
- Keep the comment and prose bar in `CLAUDE.md` only, and point `agents/stability-reviewer.md` §10 and `skills/larv-review/SKILL.md` §7 at it.
- Replace `/home/lilleman/…` in `agents/*.md` and `settings.json` with a path that holds on another machine.
- Give the `CLAUDE.md` sections `skills/larv-review/SKILL.md` cites headings it can name.
- Give the README gate, the architecture gate, the merge gate and the stability reviewer four different words; today all four are "gate".
- Raise the comprehension panel above the 7.0 floor: the 2026-09-24 four-seat run scored 5 overall, capped at 4 by Locality and Self-sufficiency, on the items above.