Python
Add scoped task reads and reconcile obsolete approvals
Rohit C Prasaddb81e29779ba
diff --git a/coworker/inbox.py b/coworker/inbox.pyindex be61a42e..4d04b734 100644--- a/coworker/inbox.py+++ b/coworker/inbox.py@@ -113,6 +113,7 @@ class InboxStore:self._lock = threading.Lock()self._items: dict[str, InboxItem] = {}self._waiters: dict[str, asyncio.Event] = {}+ self._waiter_loops: dict[str, asyncio.AbstractEventLoop] = {}self._load()# -- persistence ------------------------------------------------------------@@ -413,7 +414,9 @@ class InboxStore:for resolved_id in resolved_ids:waiter = self._waiters.get(resolved_id)if waiter is not None:- waiter.set()+ loop = self._waiter_loops.get(resolved_id)+ if loop is not None and not loop.is_closed():+ loop.call_soon_threadsafe(waiter.set)return Truedef resolve_session(@@ -436,6 +439,7 @@ class InboxStore:if item is not None and item.state == STATE_RESOLVED:return item.resolution or ""ev = self._waiters.setdefault(item_id, asyncio.Event())+ self._waiter_loops[item_id] = asyncio.get_running_loop()await ev.wait()resolved = self._items.get(item_id)return (resolved.resolution if resolved else "") or ""diff --git a/coworker/server/app.py b/coworker/server/app.pyindex 070c08ce..b96016b8 100644--- a/coworker/server/app.py+++ b/coworker/server/app.py@@ -289,6 +289,7 @@ def create_app(manager: SessionManager) -> FastAPI:@app.get("/v1/inbox")def inbox(session_id: str = "", state: str = "") -> dict[str, Any]:from dataclasses import asdict+ manager.reconcile_obsolete_prompts(session_id)# The cross-session Inbox list shows only Unattended (inbox-visibility) items; a per-session# query returns inline ones too, so the answer-in-context card sees parked attended prompts.@@ -405,6 +406,7 @@ def create_app(manager: SessionManager) -> FastAPI:@app.get("/v1/inbox/reconcile")def reconcile_inbox(session_id: str) -> dict[str, Any]:# Called when a session resumes attended control (surface pending + recap inline).+ manager.reconcile_obsolete_prompts(session_id)return manager.inbox.reconcile_on_resume(session_id)@app.get("/v1/inbox/routing")diff --git a/coworker/server/manager.py b/coworker/server/manager.pyindex 4d1f3742..0f06cf25 100644--- a/coworker/server/manager.py+++ b/coworker/server/manager.py@@ -687,6 +687,7 @@ class SessionManager:connector_requester: Optional[Any] = None,) -> Optional[TurnEngine]:engine = self._engines.get(session_id)+ self.reconcile_obsolete_prompts(session_id)if engine is not None:self.sync_worker_mode(session_id, engine)if approver is not None:@@ -1176,10 +1177,13 @@ class SessionManager:team, worker = founditem_id = Nonetry:- for it in self.team_store.list_items(team.space, self._user_actor()):- if it.get("assignee") == worker.actor and it.get("state") == "in_progress":- item_id = it.get("id")- break+ candidates = [+ it for it in self.team_store.list_items(team.space, self._user_actor())+ if it.get("assignee") == worker.actor and it.get("state") == "in_progress"+ ]+ # A session is not a task identity. Never pick the first candidate.+ if len(candidates) == 1:+ item_id = candidates[0]["id"]except Exception: # noqa: BLE001item_id = Nonetry:@@ -1691,12 +1695,38 @@ class SessionManager:if engine is not None:self.save(session_id, engine)+ def reconcile_obsolete_prompts(self, session_id: str = "") -> int:+ """Retire only tool-bound prompts whose call already has a result.++ A repaired interrupted call has a result stub too. A genuinely pending+ call has no result and remains available for durable resume.+ """+ pending = self.inbox.pending(session_id or None)+ answered_by_session = {}+ retired = 0+ for item in pending:+ if not item.tool_call_id:+ continue+ if item.session_id not in answered_by_session:+ engine = self._engines.get(item.session_id)+ record = self.session_store.load(item.session_id) if engine is None else None+ messages = engine.messages if engine is not None else (record.messages if record else [])+ answered_by_session[item.session_id] = {+ m.get("tool_call_id") for m in messages if m.get("role") == "tool"+ }+ if item.tool_call_id in answered_by_session[item.session_id]:+ if self.inbox.resolve(item.id, "interrupted", by="system:obsolete-prompt"):+ retired += 1+ return retired+async def resolve_inbox(self, item_id: str, resolution: str, by: str = "") -> bool:"""Resolve an Inbox item from any surface (REST / Slack button / channel reply). If theasking agent is still suspended live, that await handles it. Otherwise the process restarted(or the engine was evicted) while blocked → durably resume: rebuild the engine from thesaved thread and continue the turn. `by` = the deciding person when known."""item = self.inbox.get(item_id)+ if item is not None:+ self.reconcile_obsolete_prompts(item.session_id)ok = self.inbox.resolve(item_id, resolution, by=by)if not ok or item is None:return ok@@ -2952,7 +2982,7 @@ class SessionManager:sid = team.lead_sessionself._team_last_alive[sid] = time.time()message = (- "⏰ Backstop check — work is in flight but you had no check-in timer"+ "Check-in — work is in flight but you had no check-in timer"" set.\n\n"+ (self.team_staleness_digest(sid) or "Board state unavailable.")+ "\n\nGlance, act only if something needs you, and set your next"@@ -3212,7 +3242,7 @@ class SessionManager:body = "\n".join(f"- {line}" for line in lines) or "- (no detail)"if is_lead:message = (- "⏰ Board wake — your team needs decisions:\n"+ "Team update — your team needs decisions:\n"+ body+ "\n\nFull hand-off comments live on the board (get_item)."" Verify review items against their acceptance criteria (then"@@ -5107,6 +5137,8 @@ class SessionManager:async def broadcast_session(self, session_id: str, message: dict) -> None:"""Fan a turn event out to every socket viewing this session. Best-effort: a dead socketis dropped, never fatal to the turn (delivery is socket-independent)."""+ if message.get("type") == "turn_start":+ self.reconcile_obsolete_prompts(session_id)data = message.get("data") or {}if message.get("type") == "permission_required" and data.get("name") == "decide_worker_call":worker_call = self.worker_call_for(data.get("arguments") or {}, lead_session=session_id)@@ -6222,12 +6254,12 @@ class SessionManager:note = f" (note: {wake.note})" if getattr(wake, "note", "") else ""if wake.kind == "completion":return (- f"⏰ Wake — the job `{wake.job_id}` you were waiting on has completed{note}. "+ f"Check-in — the job `{wake.job_id}` you were waiting on has completed{note}. ""Continue where you left off.")if wake.kind == "event":return (- f"⏰ Wake — the event `{wake.event_key}` you were waiting on has fired{note}. "+ f"Check-in — the event `{wake.event_key}` you were waiting on has fired{note}. ""Continue where you left off.")# The fire time rides along so a woken session knows what time it is without a@@ -6235,7 +6267,7 @@ class SessionManager:fired = getattr(wake, "fire_at", None)at = f" at {fired}" if fired else ""return (- f"⏰ Wake — the timer you set has fired{at}{note}. Continue where you left off."+ f"Check-in — the timer you set has fired{at}{note}. Continue where you left off.")async def _run_scheduled_task(self, task, trigger: str) -> TaskRun:diff --git a/coworker/teams/tools.py b/coworker/teams/tools.pyindex 23416bfb..7c2ac6b6 100644--- a/coworker/teams/tools.py+++ b/coworker/teams/tools.py@@ -19,13 +19,13 @@ from .journal import JournalStorefrom .model import Actor, BoardError, Rolefrom .store import TeamStore-LEAD_VERBS = ("create_item", "list_items", "transition", "comment", "assign", "link")+LEAD_VERBS = ("create_item", "list_items", "get_item", "transition", "comment", "assign", "link")# Workers file items too (a bug spotted in passing, a follow-up) — new items land# `open` and unassigned; nothing runs until the item is assigned. `claim` is# self-assignment: on an open-claims board (the default) a worker may pick up an# open, unassigned item — the store arbitrates races, the lead supervises by# exception (every claim lands in its feed; reassign/cancel revokes).-WORKER_VERBS = ("create_item", "list_items", "transition", "comment", "claim", "set_status")+WORKER_VERBS = ("create_item", "list_items", "get_item", "transition", "comment", "claim", "set_status")JOURNAL_VERBS = ("journal_append", "journal_read")@@ -119,6 +119,14 @@ def board_tools(not change state, wake the lead, or replace evidence and review."""return _call(store.set_status, space, actor, item, text)+ def get_item(item: int) -> dict:+ """Read one visible task's full description, acceptance criteria, links,+ evidence references and comments. Scoped to this board and your identity.+ This reads board evidence, never another agent's conversation."""+ if isinstance(item, bool) or not isinstance(item, int) or item <= 0:+ return {"error": "item must be a positive integer"}+ return with_mention(_call(store.get_item, space, item, actor=actor))+def transition(item: int, to: str, comment: str = "", refs: Optional[list] = None) -> dict:diff --git a/tests/test_interactions.py b/tests/test_interactions.pyindex 8b5617d8..993dea2a 100644--- a/tests/test_interactions.py+++ b/tests/test_interactions.py@@ -75,9 +75,7 @@ def test_interaction_click_resolves_item(tmp_path):async def fake_wait(item_id):# stand in for the suspended agent: record what the item resolved to- ev = mgr.inbox._waiters.setdefault(item_id, asyncio.Event())- await ev.wait()- resolved.append(mgr.inbox.get(item_id).resolution)+ resolved.append(await mgr.inbox.wait(item_id))async def scenario():waiter = asyncio.create_task(fake_wait(item.id))diff --git a/tests/test_team_board.py b/tests/test_team_board.pyindex c6b6c745..648f6d49 100644--- a/tests/test_team_board.py+++ b/tests/test_team_board.py@@ -255,8 +255,8 @@ def test_tool_sets_are_role_filtered(store):worker_names = {tool.__name__ for tool in board_tools(store, space=SPACE, actor=WORKER)}- assert lead_names == {"create_item", "list_items", "transition", "comment", "assign", "link"}- assert worker_names == {"create_item", "list_items", "transition", "comment", "claim", "set_status"}+ assert lead_names == {"create_item", "list_items", "get_item", "transition", "comment", "assign", "link"}+ assert worker_names == {"create_item", "list_items", "get_item", "transition", "comment", "claim", "set_status"}def test_tools_return_errors_instead_of_raising(store):diff --git a/tests/test_team_reader_recovery.py b/tests/test_team_reader_recovery.pynew file mode 100644index 00000000..c9460c0e--- /dev/null+++ b/tests/test_team_reader_recovery.py@@ -0,0 +1,194 @@+"""Scoped board reads, honest approval attribution and interrupted-prompt recovery."""++import asyncio+import json+from types import SimpleNamespace+from unittest.mock import AsyncMock++import pytest+from fastapi.testclient import TestClient+from coworker.inbox import InboxStore+from coworker.server.app import create_app+from coworker.sessions import SessionRecord+from coworker.teams import Actor, Role+from coworker.teams.store import WORKER_WAITING+from coworker.teams.tools import board_tools+from test_engine import ScriptedProvider, _text_turn+from test_team_live_gaps import manager+++def create_item(manager, assignee="sam"):+ space = manager.teams.for_lead_session("lead").space+ lead = Actor(id="lead", role=Role.LEAD)+ item = manager.team_store.create_item(+ space,+ lead,+ title="Verify invoice",+ criteria="Tests pass",+ description="Acme sample",+ )+ manager.team_store.assign(space, lead, item["id"], assignee)+ return space, lead, item+++def test_get_item_tool_reads_full_evidence_with_worker_visibility(manager):+ space, lead, item = create_item(manager)+ worker = Actor(id="sam", role=Role.WORKER)+ manager.team_store.comment(+ space,+ worker,+ item["id"],+ "Evidence: " + "passed " * 200,+ refs=["test_billing.py:7"],+ )+ _, _, hidden = create_item(manager, "maya")+ read = next(+ t+ for t in board_tools(manager.team_store, space=space, actor=worker)+ if t.__name__ == "get_item"+ )+ detail = read(item["id"])+ assert detail["description"] == "Acme sample"+ assert detail["criteria"] == "Tests pass"+ assert detail["comments"][0]["body"].endswith("passed " * 200)+ assert detail["mention"].endswith(f"(task:{item['id']})")+ assert "error" in read(hidden["id"])+ for bad in (0, -1, True, "1"):+ assert "error" in read(bad)+ lead_read = next(+ t+ for t in board_tools(manager.team_store, space=space, actor=lead)+ if t.__name__ == "get_item"+ )+ assert lead_read(hidden["id"])["id"] == hidden["id"]+ assert not any(k in detail for k in ("messages", "transcript"))++[email protected]("count", [0, 1, 2])+def test_wait_attribution_requires_exactly_one_in_progress_item(manager, count):+ ids = []+ for _ in range(count):+ space, _, item = create_item(manager)+ manager.team_store.transition(+ space, Actor(id="sam", role=Role.WORKER), item["id"], "in_progress"+ )+ ids.append(item["id"])+ manager.note_worker_waiting(+ "worker", "run_shell", prompt_id="sample", preview="Run tests"+ )+ team = manager.teams.for_lead_session("lead")+ event = [+ e for e in manager.team_store.events(team.space) if e["kind"] == WORKER_WAITING+ ][-1]+ assert event["item_id"] == (ids[0] if count == 1 else None)+++def save_worker(manager, messages):+ manager.session_store.save(+ SessionRecord(+ session_id="worker",+ workspace=manager.default_workspace,+ agent="swe-worker",+ model="sample",+ mode="interactive",+ messages=messages,+ )+ )+++def call(call_id):+ return {+ "role": "assistant",+ "tool_calls": [+ {"id": call_id, "function": {"name": "run_shell", "arguments": "{}"}}+ ],+ }+++def test_restart_reconciliation_retires_answered_calls_not_unanswered_or_legacy(+ manager, monkeypatch+):+ save_worker(+ manager,+ [+ call("old"),+ {+ "role": "tool",+ "tool_call_id": "old",+ "content": '{"error":"tool call interrupted"}',+ },+ call("current"),+ ],+ )+ old = manager.inbox.add_approval(+ "worker", "Old interrupted call", tool_call_id="old"+ )+ current = manager.inbox.add_approval(+ "worker", "Current call", tool_call_id="current"+ )+ legacy = manager.inbox.add_approval("worker", "Legacy prompt")+ parent = manager.inbox.add_approval(+ "lead", "Old lead decision", data={"worker_prompt_id": old.id}+ )+ resume = AsyncMock()+ monkeypatch.setattr(manager, "_durable_resume", resume)+ assert asyncio.run(manager.resolve_inbox(old.id, "allow")) is False+ assert old.resolution == "interrupted"+ assert parent.resolution == "superseded"+ resume.assert_not_called()+ assert current.state == legacy.state == "pending"+ assert manager.reconcile_obsolete_prompts("worker") == 0+ assert asyncio.run(manager.resolve_inbox(current.id, "deny")) is True+ resume.assert_awaited_once()+ assert InboxStore(manager.inbox.path).get(old.id).resolution == "interrupted"+++def test_new_turn_repairs_and_retires_old_pending_prompt(manager):+ save_worker(manager, [call("abandoned")])+ old = manager.inbox.add_approval("worker", "Abandoned", tool_call_id="abandoned")+ manager.provider = ScriptedProvider([_text_turn("Following the new instruction.")])+ asyncio.run(manager.deliver_to_session("worker", "Do not run the old command."))+ assert old.resolution == "interrupted"+ assert not manager.inbox.pending("worker")+++def test_inbox_listing_reconciles_stale_persisted_prompt(manager):+ save_worker(+ manager, [call("old"), {"role": "tool", "tool_call_id": "old", "content": "{}"}]+ )+ old = manager.inbox.add_approval("worker", "Old", tool_call_id="old")+ client = TestClient(create_app(manager))+ result = client.get(+ "/v1/inbox", params={"session_id": "worker", "state": "pending"}+ )+ assert result.status_code == 200+ assert result.json()["items"] == []+ assert old.resolution == "interrupted"+++def test_resolution_from_http_thread_releases_async_waiter():+ store = InboxStore()+ item = store.add_approval("worker", "Sample")++ async def run():+ wait = asyncio.create_task(store.wait(item.id))+ await asyncio.sleep(0)+ await asyncio.to_thread(store.resolve, item.id, "deny")+ assert await asyncio.wait_for(wait, 1) == "deny"++ asyncio.run(run())++[email protected]("kind", ["timer", "completion", "event"])+def test_check_in_messages_have_no_alarm_emoji(manager, kind):+ wake = SimpleNamespace(+ kind=kind,+ job_id="job",+ event_key="sample",+ note="Check tests",+ fire_at="2026-09-20T12:00:00Z",+ )+ message = manager._wake_message(wake)+ assert message.startswith("Check-in")+ assert "⏰" not in message+ assert "Check tests" in message