Skip to content
Python

Add scoped task reads and reconcile obsolete approvals

Rohit C Prasaddb81e29779ba
diff --git a/coworker/inbox.py b/coworker/inbox.py
index 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 True
def 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.py
index 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.py
index 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 = found
item_id = None
try:
- 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: BLE001
item_id = None
try:
@@ -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 the
asking 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 the
saved 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_session
self._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 socket
is 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.py
index 23416bfb..7c2ac6b6 100644
--- a/coworker/teams/tools.py
+++ b/coworker/teams/tools.py
@@ -19,13 +19,13 @@ from .journal import JournalStore
from .model import Actor, BoardError, Role
from .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.py
index 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.py
index 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.py
new file mode 100644
index 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