Derive the round's state from the session file, name the steps, and test the pure core
This commit is contained in:
+6
-4
@@ -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/*/**
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
```
|
||||
|
||||
Executable
+74
@@ -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
@@ -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()
|
||||
|
||||
@@ -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()
|
||||
@@ -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.
|
||||
@@ -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.
|
||||
Reference in New Issue
Block a user