taskwarden 0.1.0__tar.gz → 0.2.0__tar.gz

taskwarden-0.2.0/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+## 0.2.0 (2026-11-04)
+
+New optional host hooks; a host without them behaves as in 0.1.0.
+
+- `clock(now)`: the time rides on the first message of each request instead of the system
+  prompt, so the prompt stays in the model's cache across runs. `BaseHost` gives a UTC line.
+- `stop_asked(task)`: the owner's Stop. Checked before each model call, each tool and before
+  parking; the run ends as `stopped`, answers every call it never reached, and posts what it
+  had already done (`STOPPED_REPLY`, `STOPPED_DID`).
+- `take_messages(task)`: what the owner writes while a task runs joins it, at the next round
+  and again before the run finishes, so one reply covers both.
+- `thought(org, thread, agent, text)`: the model's reasoning on each turn, for a live "why".
+- `decisions.apply(..., shown=)`: how the chat shows an answer when it differs from what the
+  agent reads.
+- Pictures in a user message (an owner's photo) are shown once and their words kept; a model
+  that can't see pictures is sent the words only.
+- `Usage`: each run logs its model calls and tokens, cached ones included (DeepSeek, OpenAI).
+
+## 0.1.0 (2026-11-04)
+
+First release.

{taskwarden-0.1.0 → taskwarden-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: taskwarden
-Version: 0.1.0
+Version: 0.2.0
 Summary: A durable, owner-approved AI team for a business: agents as folders, tools by risk, owner approvals that survive restarts, on Postgres.
 Project-URL: Repository, https://github.com/dahoai/taskwarden
 Author: DAHO
@@ -142,7 +142,8 @@ await sweeper.sweep(host, Session, redis, now=now, run=run) # on a timer: resume
 `BaseHost` leaves out what only your app can know. Override it as you grow:
 `sent_key` / `reach_key` (turn on the duplicate-send guard), `notify_parked` (push, SMS or
 email the owner), `refuse_run` (credits), `context` (the business's time zone), `audit`
-(store the trail), `mark` (live progress).
+(store the trail), `mark` (live progress), `thought` (the model's reasoning, as it works), `take_messages` (what the owner writes while a task runs joins it), `stop_asked` (the owner's Stop: the run ends at its next step and says what it did), `clock` (how the time reads; it rides on the
+first message of each request, never in the system prompt, so the prompt stays cached).
 
 ## Risk levels
 

{taskwarden-0.1.0 → taskwarden-0.2.0}/README.md

@@ -118,7 +118,8 @@ await sweeper.sweep(host, Session, redis, now=now, run=run) # on a timer: resume
 `BaseHost` leaves out what only your app can know. Override it as you grow:
 `sent_key` / `reach_key` (turn on the duplicate-send guard), `notify_parked` (push, SMS or
 email the owner), `refuse_run` (credits), `context` (the business's time zone), `audit`
-(store the trail), `mark` (live progress).
+(store the trail), `mark` (live progress), `thought` (the model's reasoning, as it works), `take_messages` (what the owner writes while a task runs joins it), `stop_asked` (the owner's Stop: the run ends at its next step and says what it did), `clock` (how the time reads; it rides on the
+first message of each request, never in the system prompt, so the prompt stays cached).
 
 ## Risk levels
 

{taskwarden-0.1.0 → taskwarden-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "taskwarden"
-version = "0.1.0"
+version = "0.2.0"
 description = "A durable, owner-approved AI team for a business: agents as folders, tools by risk, owner approvals that survive restarts, on Postgres."
 readme = "README.md"
 license = "Apache-2.0"

{taskwarden-0.1.0 → taskwarden-0.2.0}/taskwarden/__init__.py

@@ -6,4 +6,4 @@ call), decisions (the owner's approve / edit / decline), sweeper (background run
 columns), host (what the app supplies). See README.md.
 """
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

{taskwarden-0.1.0 → taskwarden-0.2.0}/taskwarden/decisions.py

@@ -81,7 +81,8 @@ async def claim(host, db, organization_id: str, task_id: Any, decision: str):
 async def apply(host, db, organization_id: str, task: Any, decision: str, *,
                 note: Optional[str] = None, answer: Optional[str] = None, resume: bool = False,
                 declined_calls: Optional[list[str]] = None,
-                edited_args: Optional[dict[str, dict]] = None) -> None:
+                edited_args: Optional[dict[str, dict]] = None,
+                shown: Optional[str] = None) -> None:
     """Carry out a claimed decision: run what was approved (or record the decline, the change
     asked for, or the answer), hand the results to the task and post the decision to its
     thread. `task` is the claimed task, or its id from another session. `declined_calls`: on an
@@ -149,7 +150,9 @@ async def apply(host, db, organization_id: str, task: Any, decision: str, *,
     if not is_approval:
         results = [{"role": "tool", "tool_call_id": pending.get("tool_call_id", ""),
                     "content": f"Owner answered: {answer or note or ''}"}]
-    echo, kind = answer or note or "", "text"
+    # `shown`: how the chat shows the owner's answer when it differs from what the agent
+    # reads (a file's name, not the whole file).
+    echo, kind = shown or answer or note or "", "text"
     if is_approval and decision != "revise":
         # What was decided, as data: the app words it for the owner, and the team's history
         # reads it back as one line.

{taskwarden-0.1.0 → taskwarden-0.2.0}/taskwarden/host.py

@@ -54,6 +54,18 @@ class Host(Protocol):
                             now: datetime,
                             channel: Optional[str], business_type: Optional[str],
                             self_started: bool, loaded: set[str]) -> str: ...
+    async def thought(self, organization_id: str, thread: str, agent_id: str, text: str) -> None:
+        """The model's reasoning on its latest turn, for a live "why" beside the progress
+        line. Optional; called only when the model thinks."""
+    async def take_messages(self, task: Any) -> list[str]:
+        """What the owner wrote to this task while it ran, removed as it is taken: the run
+        reads it at the start of each round and before it finishes. Optional."""
+    async def stop_asked(self, task: Any) -> bool:
+        """The owner pressed Stop on this task: checked before each model call and each tool,
+        so the run ends cleanly at the next step (loop.stop). Optional."""
+    def clock(self, now: datetime) -> Optional[str]:
+        """The time, in words, for the first message of each request. Kept out of the system
+        prompt: a prefix that changes every minute is never served from the model's cache."""
     def local_schemas(self, channel: Optional[str], task: Any) -> list[dict]:
         """Tools the host answers inside the loop itself (a `show` that draws a table, say)."""
     async def local_call(self, db: Any, organization_id: str, name: str, args: dict,
@@ -125,6 +137,8 @@ class BaseHost:
     NEVER_WAITS_NEEDS_OWNER = ("Not done: this needs the owner, and this task can't wait for "
                                "them. Put it in your report.")
     OUT_OF_STEPS = "I ran out of steps before finishing. Ask me to carry on."
+    STOPPED_REPLY = "Stopped."
+    STOPPED_DID = "Done before that: {did}."
 
     # ── Write these ──
     async def llm(self, db: Any, organization_id: str) -> tuple[Any, str]:
@@ -134,6 +148,15 @@ class BaseHost:
                             business_type, self_started, loaded) -> str:
         raise NotImplementedError("return the words the agent reads first")
 
+    async def take_messages(self, task) -> list[str]:
+        return []  # write it to let the owner add to a request while it runs
+
+    async def stop_asked(self, task) -> bool:
+        return False  # write it (a flag in Redis, say) to give the owner a Stop button
+
+    def clock(self, now) -> Optional[str]:
+        return f"Right now it is {now:%A %Y-%m-%d %H:%M} ({now.tzname()})."
+
     # ── The roster ──
     def agent(self, agent_id: str) -> Any:
         return self.agents[agent_id]

{taskwarden-0.1.0 → taskwarden-0.2.0}/taskwarden/loop.py

@@ -77,7 +77,10 @@ PRACTICE = ("Practice mode: not done, nothing was sent or changed.\n{call}\nCarr
             "request, and list in your report each action you would have taken.")
 MAX_DELEGATIONS_PER_TASK = 5  # across every run of the task, approval resumes and retries included
 DAILY_TASK_CAP = 200  # ponytail: flat per-business cap over a rolling 24h; plan-based when outgrown
-DONE, WAITING = "done", "waiting"
+DONE, WAITING, STOPPED = "done", "waiting", "stopped"
+STOPPED_BEFORE = "Not run: the owner stopped the task first."
+# A message the owner sent while the task was running (host.take_messages).
+ADDED = "The owner adds, while you work: {text}"
 THINKING = "thinking"
 
 DELEGATE_SCHEMA = {"type": "function", "function": {
@@ -248,6 +251,17 @@ def assistant_turn(msg: Any) -> dict:
     return turn
 
 
+def reasoning_of(msg: Any) -> str:
+    """The model's thinking on this turn, wherever the provider put it ("" when it had none)."""
+    turn = msg.model_dump(exclude_none=True) if hasattr(msg, "model_dump") else {}
+    found = (turn.get("reasoning_content")
+             or ((turn.get("extra_content") or {}).get("deepseek") or {}).get("reasoning_content")
+             or turn.get("reasoning"))
+    if isinstance(found, dict):
+        found = found.get("content")
+    return found.strip() if isinstance(found, str) else ""
+
+
 def tool_msg(call_id: str, content: str) -> dict:
     return {"role": "tool", "tool_call_id": call_id, "content": content}
 
@@ -352,6 +366,38 @@ async def answer_ask(host, db, child: Any, text: str) -> Optional[Any]:
     return parent
 
 
+async def asked_to_stop(host, task: Any) -> bool:
+    """The owner pressed Stop (host.stop_asked, optional: without it nothing stops a run)."""
+    check = getattr(host, "stop_asked", None)
+    return bool(check is not None and await check(task))
+
+
+async def take_added(host, task: Any) -> list[dict]:
+    """What the owner wrote since the last look, as user turns (host.take_messages, optional)."""
+    take = getattr(host, "take_messages", None)
+    texts = await take(task) if take is not None else []
+    return [{"role": "user", "content": ADDED.format(text=t)} for t in texts]
+
+
+async def stop(host, db, task: Any, history: list, did: list[str]) -> str:
+    """End the run where it is, at the owner's request. What already ran stays done, every
+    call it had not reached is answered as not run, and the chat says what was done."""
+    state = [*history]
+    calls = next((m.get("tool_calls") for m in reversed(state) if isinstance(m, dict)
+                  and m.get("role") == "assistant"), None) or []
+    answered = {m.get("tool_call_id") for m in state if isinstance(m, dict) and m.get("role") == "tool"}
+    state += [tool_msg(c["id"], STOPPED_BEFORE) for c in calls if c.get("id") not in answered]
+    task.state, task.pending, task.status = answer_dangling(state), None, STOPPED
+    reply = getattr(host, "STOPPED_REPLY", "Stopped.")
+    if did:
+        reply += " " + getattr(host, "STOPPED_DID", "Done before that: {did}.").format(did="; ".join(did))
+    host.post_message(db, organization_id=task.organization_id, thread=task.thread,
+                      sender=task.agent_id, body=reply, task_id=task.id)
+    await answer_ask(host, db, task, reply)  # a teammate waiting on this one carries on
+    await db.flush()
+    return STOPPED
+
+
 async def _finish(host, db, task: Any, history: list, text: str, actor: str,
                   shown: list) -> str:
     history.append({"role": "assistant", "content": text})
@@ -433,6 +479,17 @@ LOOK_GONE = "(pictures shown to you earlier)"
 SEES = ("deepseek", "gpt", "claude", "gemini")
 
 
+def with_clock(history: list, note: Optional[str]) -> list:
+    """The request's copy of the history with the time at the top of its first message. Not
+    stored, and fixed for the run, so each round's request starts like the last one did."""
+    if not note:
+        return history
+    first = history[0] if history else None
+    if isinstance(first, dict) and first.get("role") == "user" and isinstance(first.get("content"), str):
+        return [{**first, "content": f"{note}\n\n{first['content']}"}, *history[1:]]
+    return [{"role": "user", "content": note}, *history]
+
+
 def sees_pictures(model: str) -> bool:
     return any(family in (model or "").lower() for family in SEES)
 
@@ -446,7 +503,10 @@ def seen(history: list) -> list:
         content = msg.get("content") if isinstance(msg, dict) else None
         if isinstance(content, list) and any(p.get("type") == "image_url" for p in content
                                              if isinstance(p, dict)):
-            msg = {**msg, "content": LOOK_GONE}
+            # Words that came with the pictures (the owner's message) stay.
+            words = [p.get("text", "") for p in content if isinstance(p, dict)
+                     and p.get("type") == "text" and p.get("text") != LOOK_TEXT]
+            msg = {**msg, "content": "\n\n".join([*words, LOOK_GONE])}
         out.append(msg)
     return out
 
@@ -466,11 +526,45 @@ async def looks(host, images: list, model: str) -> Optional[dict]:
     return {"role": "user", "content": parts} if len(parts) > 1 else None
 
 
+class Usage:
+    """A run's model calls and tokens; `cached` is the part of the input the provider had seen
+    (DeepSeek's prompt cache hits, OpenAI's cached tokens), billed at a fraction."""
+
+    def __init__(self) -> None:
+        self.requests = self.prompt = self.cached = self.completion = 0
+
+    def add(self, resp: Any) -> None:
+        self.requests += 1
+        u = getattr(resp, "usage", None)
+        if u is None:
+            return
+        self.prompt += getattr(u, "prompt_tokens", 0) or 0
+        self.completion += getattr(u, "completion_tokens", 0) or 0
+        details = getattr(u, "prompt_tokens_details", None)
+        self.cached += (getattr(u, "prompt_cache_hit_tokens", 0)
+                        or getattr(details, "cached_tokens", 0) or 0)
+
+
 async def run_task(host, db, task: Any, *, actor: str = "task",
                    llm: Optional[tuple[Any, str]] = None, now: Optional[datetime] = None,
                    channel: Optional[str] = None, budget_seconds: Optional[float] = None) -> str:
     """One run of a task. With `budget_seconds`, a run still working when the time is up
-    checkpoints (status "queued") instead of being cut off mid-tool by its caller's timeout."""
+    checkpoints (status "queued") instead of being cut off mid-tool by its caller's timeout.
+    Logs the run's tokens (`taskwarden_run_usage`) however it ends."""
+    usage = Usage()
+    try:
+        return await _run(host, db, task, usage, actor=actor, llm=llm, now=now, channel=channel,
+                          budget_seconds=budget_seconds)
+    finally:
+        if usage.requests:
+            logger.info("taskwarden_run_usage task_id=%s agent=%s requests=%s prompt=%s "
+                        "cached=%s completion=%s", task.id, task.agent_id, usage.requests,
+                        usage.prompt, usage.cached, usage.completion)
+
+
+async def _run(host, db, task: Any, usage: Usage, *, actor: str, llm: Optional[tuple[Any, str]],
+               now: Optional[datetime], channel: Optional[str],
+               budget_seconds: Optional[float]) -> str:
     started = time.monotonic()
     now = now or datetime.now(timezone.utc)
     org = task.organization_id
@@ -515,6 +609,8 @@ async def run_task(host, db, task: Any, *, actor: str = "task",
     local_now = now.astimezone(ZoneInfo(ctx.timezone))
     system = {"role": "system", "content": await host.system_prompt(
         db, task, agent, name, teammates, local_now, channel, business_type, self_started, loaded)}
+    clock = getattr(host, "clock", None)
+    note = clock(local_now) if clock else None
     Task = host.Task
     # Work this task already handed to someone counts, so a loop of hand-offs cannot outrun
     # the caps across approval resumes and retries.
@@ -534,7 +630,11 @@ async def run_task(host, db, task: Any, *, actor: str = "task",
     # show from it: posted under its answer, dropped if the run parks instead.
     reads: dict[str, Any] = {}
     shown: list[dict] = []
+    did: list[str] = []  # what this run changed or sent, for the owner if they stop it
     for round_no in range(MAX_ROUNDS):
+        if await asked_to_stop(host, task):
+            return await stop(host, db, task, history, did)
+        history += await take_added(host, task)
         if round_no and too_long(history):
             history = compact(history)
         if round_no and stalled(history, 2) and not any(
@@ -551,10 +651,14 @@ async def run_task(host, db, task: Any, *, actor: str = "task",
             return "queued"
         await host.mark(org, task.thread, agent.id, THINKING)
         resp = await client.chat.completions.create(
-            model=model, extra_body=host.extra_body(model), messages=[system, *history],
+            model=model, extra_body=host.extra_body(model),
+            messages=[system, *with_clock(history if sees_pictures(model) else seen(history), note)],
             tools=tools, tool_choice="auto")
+        usage.add(resp)
         history = seen(history)  # the pictures were seen; they are not kept
         msg = resp.choices[0].message
+        if (think := getattr(host, "thought", None)) is not None and (text := reasoning_of(msg)):
+            await think(org, task.thread, agent.id, text)  # the owner can see why, as it works
         if not msg.tool_calls:
             text = host.clean_text(msg.content)
             if not grounded and not nudged and states_a_figure(text):
@@ -569,6 +673,11 @@ async def run_task(host, db, task: Any, *, actor: str = "task",
                             {"role": "user", "content": UNFINISHED}]
                 task.state = list(history)
                 continue
+            if added := await take_added(host, task):
+                # The owner wrote while this was being written: answer that too, in one reply.
+                history += [{"role": "assistant", "content": text}, *added]
+                task.state = list(history)
+                continue
             return await _finish(host, db, task, history, text, actor, shown)
         history.append(assistant_turn(msg))
         parked: Optional[dict] = None
@@ -710,6 +819,8 @@ async def run_task(host, db, task: Any, *, actor: str = "task",
                                  "args": host.clean_args(args)})
                 continue
             if decision.outcome == gate.ALLOW:
+                if await asked_to_stop(host, task):
+                    return await stop(host, db, task, history, did)
                 await host.mark(org, task.thread, agent.id, tool_name)
                 if sent is not None:
                     # Saved before it runs: a crash mid-send must not lead to a second send.
@@ -727,6 +838,8 @@ async def run_task(host, db, task: Any, *, actor: str = "task",
                 if ok:
                     grounded = True
                 if ok is not False:  # None: stopped at its timeout, it may have gone out
+                    if tool.risk != READ:
+                        did.append(f"{tool_name} ({target})" if target else tool_name)
                     if reach is not None:
                         # Only a send that (maybe) went out counts: a rejected one leaves
                         # the retry open, which is the whole point of retrying.
@@ -746,6 +859,8 @@ async def run_task(host, db, task: Any, *, actor: str = "task",
         task.state, task.contacted = list(history), sorted(sent_task)
         if parked is None and not awaiting:
             await db.commit()  # the round's progress survives a restart
+        if (parked is not None or awaiting) and await asked_to_stop(host, task):
+            return await stop(host, db, task, history, did)
         if parked is not None:
             # A question wins over a batch in the same response: the answer may change what to
             # send. Each held call still needs its tool message; the model proposes it again.
@@ -764,9 +879,12 @@ async def run_task(host, db, task: Any, *, actor: str = "task",
             task.state = list(history)
             return await park(host, db, task, history, batch, name, actor, channel, now)
 
+    if await asked_to_stop(host, task):
+        return await stop(host, db, task, history, did)
     wrap_up = {"role": "user", "content": WRAP_UP}
     resp = await client.chat.completions.create(model=model, extra_body=host.extra_body(model),
-                                                messages=[system, *history, wrap_up])
+                                                messages=[system, *with_clock(history, note), wrap_up])
+    usage.add(resp)
     text = resp.choices[0].message.content or ""
     return await _finish(host, db, task, history, host.clean_text(text) or host.OUT_OF_STEPS,
                          actor, shown)

{taskwarden-0.1.0 → taskwarden-0.2.0}/taskwarden/sweeper.py

@@ -33,7 +33,7 @@ OWNER_ORIGIN = "owner"
 
 
 async def retry_or_fail(host, db, task: Any) -> None:
-    if task.status in ("waiting", "done"):
+    if task.status in ("waiting", "done", "stopped"):
         return  # the run parked or finished before failing; its committed state stands
     if (task.attempts or 0) >= MAX_ATTEMPTS:
         task.status, task.pending = "failed", None

{taskwarden-0.1.0 → taskwarden-0.2.0}/tests/test_taskwarden.py

@@ -13,6 +13,7 @@ import uuid
 import pytest
 from contextlib import nullcontext
 from dataclasses import dataclass, field, replace
+from datetime import datetime, timezone
 from types import SimpleNamespace
 from unittest.mock import AsyncMock, MagicMock
 
@@ -347,3 +348,152 @@ def test_the_shop_example_runs(capsys):
     out = capsys.readouterr().out
     assert "waits: refund {'order_id': 'A7'}" in out
     assert "[lead] Done: I refunded order A8, $19.50." in out
+
+
+# ── A run's tokens are logged, with what the provider had cached ──
+
+def test_usage_counts_deepseek_and_openai_cache_hits():
+    u = loop.Usage()
+    u.add(SimpleNamespace(usage=SimpleNamespace(prompt_tokens=1000, completion_tokens=50,
+                                                prompt_cache_hit_tokens=900)))  # DeepSeek
+    u.add(SimpleNamespace(usage=SimpleNamespace(prompt_tokens=800, completion_tokens=20,
+                                                prompt_tokens_details=SimpleNamespace(cached_tokens=640))))  # OpenAI
+    u.add(SimpleNamespace())  # no usage reported
+    assert (u.requests, u.prompt, u.cached, u.completion) == (3, 1800, 1540, 70)
+
+
+async def test_a_run_logs_its_usage_however_it_ends(caplog):
+    host, task = ShopHost(), _task()
+    llm = _llm(Msg(calls=[("read_orders", {})]), Msg("Two orders came in today."))
+    with caplog.at_level("INFO", logger="taskwarden.loop"):
+        assert await loop.run_task(host, _db(), task, llm=(llm, "m")) == "done"
+    assert any("taskwarden_run_usage" in r.getMessage() and "requests=2" in r.getMessage()
+               for r in caplog.records)
+
+
+class ClockHost(ShopHost):
+    def clock(self, now): return f"It is {now:%H:%M}."
+
+
+async def test_the_clock_tops_every_request_and_is_never_stored_or_in_the_system_prompt():
+    host, task, sent = ClockHost(), _task(), []
+    replies = [Msg(calls=[("read_orders", {})]), Msg("Two orders.")]
+
+    async def create(**kw):
+        sent.append(kw["messages"])
+        return SimpleNamespace(choices=[SimpleNamespace(message=replies.pop(0))])
+    llm = SimpleNamespace(chat=SimpleNamespace(completions=SimpleNamespace(create=create)))
+    now = datetime(2026, 11, 5, 9, 30, tzinfo=timezone.utc)
+    assert await loop.run_task(host, _db(), task, llm=(llm, "m"), now=now) == "done"
+    assert [m[1]["content"] for m in sent] == ["It is 09:30.\n\nHow are orders today?"] * 2
+    assert all("09:30" not in m[0]["content"] for m in sent)
+    assert task.state[0] == {"role": "user", "content": "How are orders today?"}
+
+
+@dataclass
+class StoppableHost(TextingHost):
+    stop_after: int = 0  # Stop is pressed once this many texts went out
+    texts: int = 0
+
+    async def stop_asked(self, task):
+        return self.texts >= self.stop_after
+
+    async def execute(self, tool, ctx, args):
+        self.texts += tool.name == "send_text"
+        return await super().execute(tool, ctx, args)
+
+
+async def test_a_stop_pressed_before_the_run_ends_it_before_the_model_is_asked():
+    host, task = StoppableHost(stop_after=0), _task()
+    assert await loop.run_task(host, _db(), task, llm=(_llm(), "m")) == "stopped"
+    assert task.status == "stopped" and host.posted[-1]["body"] == "Stopped."
+
+
+async def test_a_stop_mid_round_keeps_what_was_sent_and_runs_nothing_more():
+    host, task = StoppableHost(stop_after=1), _task()
+    host.agent = lambda agent_id: Agent(agent_id, "Lead", tools=("read_orders", "send_text"))
+    llm = _llm(Msg(calls=[("send_text", {"to": "+1555", "body": "Hi"}),
+                          ("send_text", {"to": "+1666", "body": "Hi"})]))
+    assert await loop.run_task(host, _db(), task, llm=(llm, "m")) == "stopped"
+    assert host.texts == 1
+    assert host.posted[-1]["body"] == "Stopped. Done before that: send_text (+1555)."
+    tool_results = [m["content"] for m in task.state if m.get("role") == "tool"]
+    assert tool_results == ["Sent to +1555.", loop.STOPPED_BEFORE]  # every call answered
+
+
+@dataclass
+class ChattyHost(ShopHost):
+    inbox: list = field(default_factory=list)  # (look number, text): what the owner sends when
+    looks: int = 0
+
+    async def take_messages(self, task):
+        self.looks += 1
+        return [text for at, text in self.inbox if at == self.looks]
+
+
+def _recording(*replies):
+    sent, queue = [], list(replies)
+
+    async def create(**kw):
+        sent.append(kw["messages"])
+        return SimpleNamespace(choices=[SimpleNamespace(message=queue.pop(0))])
+    return SimpleNamespace(chat=SimpleNamespace(completions=SimpleNamespace(create=create))), sent
+
+
+async def test_a_message_sent_mid_run_reaches_the_next_round():
+    host, task = ChattyHost(inbox=[(2, "Only count paid ones.")]), _task()
+    llm, sent = _recording(Msg(calls=[("read_orders", {})]), Msg("One paid order."))
+    assert await loop.run_task(host, _db(), task, llm=(llm, "m")) == "done"
+    assert sent[1][-1] == {"role": "user", "content": "The owner adds, while you work: Only count paid ones."}
+    assert host.posted[-1] == {"body": "One paid order."}
+
+
+async def test_a_message_sent_as_the_reply_was_written_gets_one_reply_covering_both():
+    host, task = ChattyHost(inbox=[(2, "And yesterday?")]), _task()
+    llm, sent = _recording(Msg("Two orders today."), Msg("Two today, three yesterday."))
+    assert await loop.run_task(host, _db(), task, llm=(llm, "m")) == "done"
+    assert [m["content"] for m in sent[1][-2:]] == [
+        "Two orders today.", "The owner adds, while you work: And yesterday?"]
+    assert [p["body"] for p in host.posted] == ["Two today, three yesterday."]
+
+
+class Thinking(Msg):
+    def __init__(self, reasoning, **kw):
+        super().__init__(**kw)
+        self.reasoning = reasoning
+
+    def model_dump(self, exclude_none=False):
+        return {**super().model_dump(exclude_none), "reasoning_content": self.reasoning}
+
+
+@dataclass
+class ThinkingHost(ShopHost):
+    thoughts: list = field(default_factory=list)
+
+    async def thought(self, org, thread, agent_id, text):
+        self.thoughts.append((agent_id, text))
+
+
+async def test_the_models_thinking_is_handed_to_the_host_as_it_works():
+    host, task = ThinkingHost(), _task()
+    llm = _llm(Thinking("Read the orders first.", calls=[("read_orders", {})]), Msg("Two orders."))
+    assert await loop.run_task(host, _db(), task, llm=(llm, "m")) == "done"
+    assert host.thoughts == [("lead", "Read the orders first.")]  # a turn with none says nothing
+
+
+def test_a_picture_seen_once_leaves_the_words_it_came_with():
+    owner = {"role": "user", "content": [{"type": "text", "text": "Post this photo"},
+                                         {"type": "image_url", "image_url": {"url": "data:x"}}]}
+    assert loop.seen([owner]) == [{"role": "user", "content": f"Post this photo\n\n{loop.LOOK_GONE}"}]
+    look = {"role": "user", "content": [{"type": "text", "text": loop.LOOK_TEXT},
+                                        {"type": "image_url", "image_url": {"url": "data:x"}}]}
+    assert loop.seen([look]) == [{"role": "user", "content": loop.LOOK_GONE}]
+
+
+async def test_a_model_that_cant_see_is_never_sent_a_picture():
+    host, task = ShopHost(), _task()
+    task.state = [{"role": "user", "content": [{"type": "text", "text": "What is this?"},
+                                               {"type": "image_url", "image_url": {"url": "data:x"}}]}]
+    llm, sent = _recording(Msg("A receipt."))
+    assert await loop.run_task(host, _db(), task, llm=(llm, "llama-3")) == "done"
+    assert "image_url" not in json.dumps(sent[0])