Track loop-claude; continue an unfinished chunk in its session and reload the script each round

This commit is contained in:
2026-09-24 20:10:37 +02:00
parent 2b3930d05a
commit 8f647f8596
4 changed files with 319 additions and 1 deletions
+2
View File
@@ -14,6 +14,8 @@
!agent-shared/**
!agents/
!agents/*.md
!bin/
!bin/*
!principles/
!principles/*.md
!skills/
+4
View File
@@ -12,6 +12,10 @@ My personal `~/.claude`, version controlled. Instructions, agents, skills, princ
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`.
## 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>`:
+312
View File
@@ -0,0 +1,312 @@
#!/usr/bin/env python3
import glob
import json
import os
import subprocess
import sys
import time
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")
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_SCHEMA = {
"properties": {
"ask": {"type": "boolean"},
"evidence": {"description": "A verbatim quote from the transcript of the line that raises the question. Empty when ask is false.", "type": "string"},
"finished": {"description": "True when the chunk is complete: merged, or nothing remains that the agent could do on its own.", "type": "boolean"},
"question": {"description": "The single question to put to the human. Empty when ask is false.", "type": "string"},
},
"required": ["ask", "evidence", "finished", "question"],
"type": "object",
}
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 {}
found, current = {}, None
for line in lines:
if line.startswith("## "):
current = line.strip()[3:]
found[current] = []
elif current and line.strip():
found[current].append(line)
return {name: "\n".join(body) for name, body in found.items() if body}
def project_path():
root = os.path.expanduser("~/code")
cwd = os.getcwd()
if cwd == root:
return "code"
if cwd.startswith(f"{root}/"):
return os.path.relpath(cwd, root)
return cwd.lstrip("/")
def session_name():
root = os.path.expanduser("~/code")
cwd = os.getcwd()
if cwd == root:
return "A ~/code auto-mode"
if cwd.startswith(f"{root}/"):
return f"A ~/code/{os.path.relpath(cwd, root)} auto-mode"
return f"A {cwd} auto-mode"
def slot_file(session_id):
hit = glob.glob(os.path.expanduser(f"~/.claude/projects/*/{session_id}.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)
except ValueError:
continue
if isinstance(entry, dict):
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):
said = []
for entry in entries(path):
if entry.get("type") != "assistant":
continue
for part in entry.get("message", {}).get("content", []):
if not isinstance(part, dict):
continue
if part.get("type") == "text" and part.get("text", "").strip():
said.append(part["text"])
elif part.get("type") == "tool_use":
said.append(f"[tool {part.get('name')}] {json.dumps(part.get('input'))[:400]}")
return "\n\n".join(said)
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)))
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")
except OSError as failure:
print(f"could not archive the transcript: {failure}", file=sys.stderr)
return ""
return dest
def checkouts():
found = [os.getcwd()]
listing = subprocess.run(["git", "worktree", "list", "--porcelain"], capture_output=True, text=True)
if listing.returncode == 0:
found += [line.split(" ", 1)[1] for line in listing.stdout.splitlines() if line.startswith("worktree ")]
return sorted(set(found))
def trust(paths):
config = os.path.expanduser("~/.claude.json")
try:
data = json.load(open(config, encoding="utf-8"))
except (OSError, ValueError):
return []
projects = data.setdefault("projects", {})
granted = [path for path in paths if not projects.setdefault(path, {}).get("hasTrustDialogAccepted")]
if not granted:
return []
for path in granted:
projects[path]["hasTrustDialogAccepted"] = True
staged = f"{config}.loop-claude"
try:
with open(staged, "w", encoding="utf-8") as handle:
json.dump(data, handle, indent=2)
os.replace(staged, config)
except OSError as failure:
print(f"could not record trust: {failure}", file=sys.stderr)
return []
return granted
def interrupt(task, premises, work):
verdict = claude([
"-p",
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.",
"--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
return verdict
def reload(state):
try:
source = open(__file__, encoding="utf-8").read()
compile(source, __file__, "exec")
except (OSError, SyntaxError) as failure:
print(f"keeping the running script: {failure}", file=sys.stderr)
return
if source == SOURCE:
return
os.environ[STATE] = json.dumps(state)
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"])
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
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"]
+1 -1
View File
@@ -5,7 +5,7 @@ description: One-stop shipping pipeline for a work chunk - branch, commit, push,
# larv-review — ship the chunk, review until clean, gate green, merge
You orchestrate, fix, and ship; the reviewer agents only report. Run every reviewer synchronously (`run_in_background: false`) — each step depends on the previous result. Architecture strictly before security, security before stability: line-level polish on code the architect wants restructured, or on a call the security pass will rewrite, is wasted work. The full order is architecture → security → stability → product-owner when escalated → a closing stability round over what that changed.
You orchestrate, fix, and ship; the reviewer agents only report. Run every reviewer synchronously (`run_in_background: false`) — each step depends on the previous result. Watch CI in the foreground too: a headless run exits when the turn ends, and a background watcher or a scheduled wakeup dies with it. A reviewer's report is input to the next step; the turn runs on until §12. Architecture strictly before security, security before stability: line-level polish on code the architect wants restructured, or on a call the security pass will rewrite, is wasted work. The full order is architecture → security → stability → product-owner when escalated → a closing stability round over what that changed.
**Forge-neutral.** Five PR operations recur below: read a PR's diff, open a draft PR, read check status, mark ready, merge. Resolve the tooling from the remote per the global git rules (`gh` on GitHub, `tea` on Gitea); on any other forge, achieve the same intents through its CLI or API — discover how rather than assuming. A forge without a native draft state gets the closest equivalent (a `WIP:`/`Draft:` title prefix); note any approximation in the summary.