Track loop-claude; continue an unfinished chunk in its session and reload the script each round
This commit is contained in:
@@ -14,6 +14,8 @@
|
||||
!agent-shared/**
|
||||
!agents/
|
||||
!agents/*.md
|
||||
!bin/
|
||||
!bin/*
|
||||
!principles/
|
||||
!principles/*.md
|
||||
!skills/
|
||||
|
||||
@@ -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>`:
|
||||
|
||||
Executable
+312
@@ -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"]
|
||||
@@ -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.
|
||||
|
||||
|
||||
Reference in New Issue
Block a user