def agent_loop(messages: list):
    while True:
        response = client.messages.create(
            model=MODEL, system=SYSTEM,
            messages=messages, tools=TOOLS,
            max_tokens=8000,
        )
        messages.append({"role": "assistant",
                         "content": response.content})

        if response.stop_reason != "tool_use":
            return

        results = []
        for block in response.content:
            if block.type == "tool_use":
                output = run_bash(block.input["command"])
                results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": output,
                })
        messages.append({"role": "user", "content": results})

TOOL_HANDLERS = {
    "bash":       lambda **kw: run_bash(kw["command"]),
    "read_file":  lambda **kw: run_read(kw["path"], kw.get("limit")),
    "write_file": lambda **kw: run_write(kw["path"], kw["content"]),
    "edit_file":  lambda **kw: run_edit(kw["path"], kw["old_text"], kw["new_text"]),
}

class TodoManager:
    def update(self, items: list) -> str:
        in_progress = [i for i in items
                       if i.get("status") == "in_progress"]
        if len(in_progress) > 1:
            return "Error: only 1 task can be in_progress"
        self.items = items
        return self.render()

    def render(self) -> str:
        lines = []
        for i, item in enumerate(self.items):
            mark = {"pending": " ",
                    "in_progress": ">",
                    "completed": "x"}
            lines.append(
                f"[{mark[item['status']]}] #{i+1}: {item['subject']}")
        done = sum(1 for i in self.items
                   if i["status"] == "completed")
        lines.append(f"({done}/{len(self.items)} completed)")
        return "\n".join(lines)

rounds_since_todo = 0
if rounds_since_todo >= 3:
    results.append({
        "type": "text",
        "text": "<reminder>Update your todos.</reminder>"
    })

def run_subagent(prompt: str) -> str:
    sub_messages = [{"role": "user",
                     "content": prompt}]
    for _ in range(30):
        response = client.messages.create(
            model=MODEL,
            system=SUBAGENT_SYSTEM,
            messages=sub_messages,
            tools=CHILD_TOOLS,
            max_tokens=8000,
        )
        sub_messages.append(
            {"role": "assistant",
             "content": response.content})
        if response.stop_reason != "tool_use":
            break
        # ... execute tools ...
    return "".join(b.text for b in response.content
                   if hasattr(b, "text"))

class SkillLoader:
    def _load_all(self):
        for f in sorted(self.skills_dir.rglob("SKILL.md")):
            text = f.read_text()
            meta, body = self._parse_frontmatter(text)
            self.skills[meta["name"]] = {
                "meta": meta, "body": body,
            }

    def get_content(self, name: str) -> str:
        skill = self.skills.get(name)
        if not skill:
            return f"Skill '{name}' not found."
        return f"<skill name=\"{name}\">\n{skill['body']}\n</skill>"

def auto_compact(messages: list) -> list:
    transcript_path = TRANSCRIPTS_DIR / \
        f"transcript_{int(time.time())}.jsonl"
    with open(transcript_path, "w") as f:
        for msg in messages:
            f.write(json.dumps(msg) + "\n")

    summary_response = client.messages.create(
        model=MODEL,
        system="Summarize this conversation.",
        messages=[{"role": "user",
                   "content": str(messages)}],
        max_tokens=2000,
    )
    summary = summary_response.content[0].text
    return [
        {"role": "user",
         "content": f"<summary>{summary}</summary>"},
        {"role": "assistant",
         "content": "Understood. Continuing."},
    ]

class TaskManager:
    def create(self, subject: str,
              description: str = "") -> str:
        task = {
            "id": self._next_id,
            "subject": subject,
            "description": description,
            "status": "pending",
            "blockedBy": [],
            "owner": "",
        }
        path = TASKS_DIR / f"task_{task['id']}.json"
        path.write_text(json.dumps(task, indent=2))
        self._next_id += 1
        return f"Created task #{task['id']}"

def _clear_dependency(self, completed_id: int):
    for f in TASKS_DIR.glob("task_*.json"):
        task = json.loads(f.read_text())
        if completed_id in task.get("blockedBy", []):
            task["blockedBy"].remove(completed_id)
            f.write_text(json.dumps(task, indent=2))

class BackgroundManager:
    def run(self, command: str) -> str:
        task_id = str(uuid.uuid4())[:8]
        self.tasks[task_id] = {
            "status": "running",
            "result": None,
            "command": command,
        }
        thread = threading.Thread(
            target=self._execute,
            args=(task_id, command),
            daemon=True,
        )
        thread.start()
        return f"Background task {task_id} started"

class MessageBus:
    def send(self, sender: str, to: str,
             content: str,
             msg_type: str = "message"):
        msg = {
            "type": msg_type,
            "from": sender,
            "content": content,
            "timestamp": time.time(),
        }
        inbox = self.inbox_dir / f"{to}.jsonl"
        with open(inbox, "a") as f:
            f.write(json.dumps(msg) + "\n")

    def read_inbox(self, name: str) -> list:
        inbox = self.inbox_dir / f"{name}.jsonl"
        if not inbox.exists():
            return []
        text = inbox.read_text().strip()
        msgs = [json.loads(l)
                for l in text.splitlines()]
        inbox.write_text("")
        return msgs

unclaimed = scan_unclaimed_tasks()
if unclaimed:
    task = unclaimed[0]
    claim_task(task["id"], name)
    messages.append({
        "role": "user",
        "content": f"<auto-claimed>Task #{task['id']}: {task['subject']}"
    })
    resume = True

class WorktreeManager:
    def create(self, name: str,
              task_id: int = None,
              base_ref: str = "HEAD") -> str:
        wt_path = self.base_dir / name
        branch = f"wt/{name}"
        subprocess.run(
            ["git", "worktree", "add",
             "-b", branch,
             str(wt_path), base_ref],
            cwd=str(self.repo_root),
            check=True,
        )
        entry = {
            "name": name,
            "path": str(wt_path),
            "branch": branch,
            "task_id": task_id,
            "status": "active",
        }
        self._add_to_index(entry)
        if task_id:
            self._bind_task(task_id, name)
        self.events.emit(
            "worktree.create.after",
            worktree=entry)