Python
Fix team approval handoffs and self-wake behavior
Rohit C Prasadf7fcd0d26002
diff --git a/coworker/agent.py b/coworker/agent.pyindex e9004487..ef87c512 100644--- a/coworker/agent.py+++ b/coworker/agent.py@@ -436,7 +436,7 @@ def build_engine()# Self-wake: scheduling surfaces can suspend + schedule their own resumption (timer /# on-completion / on-event). The scheduler tick resumes due wakes.- if wake_store is not None and session_id and agent.scheduling:+ if wake_store is not None and session_id and (agent.scheduling or agent.team == "lead"):registry.register_all(selfwake_tools(wake_store, session_id))# The clock, on demand, for every surface: the system prompt's "Today's date" is a# session-start snapshot, and the per-turn context block must not carry a live timediff --git a/coworker/engine.py b/coworker/engine.pyindex fa2cd231..77def1e2 100644--- a/coworker/engine.py+++ b/coworker/engine.py@@ -82,6 +82,7 @@ class ApprovalOutcome(str, Enum):# nothing persisted. EXTERNAL-risk tools only (validated server-side).THIS_RUN = "this_run"DENY = "deny"+ SUPERSEDED = "superseded"def _readonly_ok(arguments: dict) -> bool:@@ -492,11 +493,15 @@ class TurnEngine:if not pending:returnself._cancel.clear()+ self._yield_for_wake = Falseyield Event(EventType.TURN_START, {"input": "(resumed)"})async for event in self._handle_tool_calls(pending):yield eventyield Event(EventType.ITERATION_END, {"iteration": 0})if not self._cancel.is_set():+ if self._yield_for_wake:+ yield Event(EventType.TURN_END, {"status": "sleeping", "iterations": 0})+ returnasync for event in self._loop():yield event@@ -563,6 +568,7 @@ class TurnEngine:return []async def _loop(self) -> AsyncIterator[Event]:+ self._yield_for_wake = Falseiterations = 0self._continuations = 0while True:@@ -787,6 +793,9 @@ class TurnEngine:self._append_notice("interrupted")yield Event(EventType.INTERRUPTED, {"iterations": iterations})return+ if self._yield_for_wake:+ yield Event(EventType.TURN_END, {"status": "sleeping", "iterations": iterations})+ returnif self._steering:self._inject_steering()@@ -1618,6 +1627,21 @@ class TurnEngine:),interrupted=ApprovalOutcome.DENY,)+ if outcome is ApprovalOutcome.SUPERSEDED:+ result = {+ "skipped": True,+ "reason": "The worker request was already resolved. No further action was taken.",+ }+ self._approval_origins.pop(tool_call.id, None)+ self.messages.append(self._timed_result(tool_call, result))+ self._audit(tool_call, stage="approval_resolved", call_id=tool_call.id, status="superseded", reason=result["reason"])+ self._audit(tool_call, stage="finished", status="skipped", reason=result["reason"])+ yield Event(EventType.TOOL_FINISHED, {+ "name": tool_call.name, "status": "ok", "result_preview": json.dumps(result),+ "superseded_worker_call": (tool_call.arguments or {}).get("call_id") if tool_call.name == "decide_worker_call" else None,+ })+ yield False+ returnif outcome is ApprovalOutcome.DENY:allowed, reason = (False,@@ -1717,6 +1741,12 @@ class TurnEngine:self._tool_timings.setdefault(tool_call.id, {}).update(tool_started=started, tool_ms=(time.monotonic() - clock) * 1000)def _record_result(self, tool_call: ToolCall, result: Any, status: str) -> Event:+ spec = self.registry.get(tool_call.name)+ if (+ status == "ok" and isinstance(result, dict) and result.get("ok")+ and spec and getattr(spec.func, "__coworker_yields_turn__", False)+ ):+ self._yield_for_wake = Trueself._step += 1if status == "ok":# Only successful calls: a write that raised left nothing on disk to run.diff --git a/coworker/inbox.py b/coworker/inbox.pyindex 622c9173..be61a42e 100644--- a/coworker/inbox.py+++ b/coworker/inbox.py@@ -174,6 +174,10 @@ class InboxStore:)with self._lock:self._items[item.id] = item+ source_id = item.data.get("worker_prompt_id")+ source = self._items.get(source_id) if isinstance(source_id, str) else None+ if source is not None and source.state == STATE_RESOLVED:+ self._supersede_locked(item, source)self._save()return item@@ -373,6 +377,23 @@ class InboxStore:return self.list(session_id=session_id, state=STATE_PENDING)# -- the state machine ------------------------------------------------------+ @staticmethod+ def _resolve_locked(item: InboxItem, resolution: str, by: str) -> None:+ item.state = STATE_RESOLVED+ item.resolution = resolution+ item.resolved_at = _now()+ item.resolved_by = (by or "").strip()++ @classmethod+ def _supersede_locked(cls, item: InboxItem, source: InboxItem) -> None:+ cls._resolve_locked(item, "superseded", "system:worker-resolution")+ if isinstance(item.data.get("worker_call"), dict):+ item.data["worker_call"] = {+ **item.data["worker_call"],+ "state": source.state,+ "resolution": source.resolution,+ }+def resolve(self, item_id: str, resolution: str, by: str = "") -> bool:"""Resolve an item exactly once. First responder wins; later attempts are no-ops(return False). Fires any awaiting agent (the suspended inbox_approver).@@ -382,14 +403,17 @@ class InboxStore:item = self._items.get(item_id)if item is None or item.state == STATE_RESOLVED:return False- item.state = STATE_RESOLVED- item.resolution = resolution- item.resolved_at = _now()- item.resolved_by = (by or "").strip()+ self._resolve_locked(item, resolution, by)+ resolved_ids = [item_id]+ for dependent in self._items.values():+ if dependent.state == STATE_PENDING and dependent.data.get("worker_prompt_id") == item_id:+ self._supersede_locked(dependent, item)+ resolved_ids.append(dependent.id)self._save()- waiter = self._waiters.get(item_id)- if waiter is not None:- waiter.set()+ for resolved_id in resolved_ids:+ waiter = self._waiters.get(resolved_id)+ if waiter is not None:+ waiter.set()return Truedef resolve_session(@@ -407,10 +431,11 @@ class InboxStore:async def wait(self, item_id: str) -> str:"""Await an item's resolution; returns the resolution string. Used by the approver tosuspend the agent until a human answers (from any surface)."""- item = self._items.get(item_id)- if item is not None and item.state == STATE_RESOLVED:- return item.resolution or ""- ev = self._waiters.setdefault(item_id, asyncio.Event())+ with self._lock:+ item = self._items.get(item_id)+ if item is not None and item.state == STATE_RESOLVED:+ return item.resolution or ""+ ev = self._waiters.setdefault(item_id, asyncio.Event())await ev.wait()resolved = self._items.get(item_id)return (resolved.resolution if resolved else "") or ""diff --git a/coworker/selfwake.py b/coworker/selfwake.pyindex d68a6694..d244084f 100644--- a/coworker/selfwake.py+++ b/coworker/selfwake.py@@ -188,4 +188,7 @@ def selfwake_tools(store: WakeStore, session_id: str) -> list:w = store.add_event(session_id, event_key, note=note)return {"ok": True, "wake_id": w.id, "event_key": event_key}- return [sleep_for, sleep_until, wake_on, wake_on_event]+ tools = [sleep_for, sleep_until, wake_on, wake_on_event]+ for tool in tools:+ tool.__coworker_yields_turn__ = True+ return toolsdiff --git a/coworker/server/app.py b/coworker/server/app.pyindex 7765e0a2..070c08ce 100644--- a/coworker/server/app.py+++ b/coworker/server/app.py@@ -2881,11 +2881,6 @@ def create_app(manager: SessionManager) -> FastAPI:# it COULD be given (declared ceiling ∩ connected) — computed here,# where the manager is at hand; the engine only knows the roster.data = {**data, **manager.team_card_extras(session_id, data.get("members") or [])}- elif event.type is EventType.PERMISSION_REQUIRED and data.get("name") == "decide_worker_call":- # The card shows the worker's call the lead is deciding, not its id.- worker_call = manager.worker_call_for(data.get("arguments") or {})- if worker_call:- data = {**data, "worker_call": worker_call}# Broadcast to every socket viewing this session (this socket included — it's a# registered client), so a second view of the same session stays in sync too.await manager.broadcast_session(diff --git a/coworker/server/manager.py b/coworker/server/manager.pyindex 76896541..4d1f3742 100644--- a/coworker/server/manager.py+++ b/coworker/server/manager.py@@ -2978,6 +2978,11 @@ class SessionManager:# on their slice (assigned ∪ filed) — comments, moves, reassignments. The# lead additionally subscribes to the board-wide decision classes.directs = self.team_store.feed_for(team.space, actor)+ if not is_lead and directs and all(e["kind"] == WORKER_WAITING for e in directs):+ # A wait owned by the lead/user is not work for a worker. Advance+ # this informational-only batch so it cannot repeatedly wake them.+ self.team_store.consume_feed(team.space, actor, max(e["seq"] for e in directs))+ directs = []subs = (self.team_store.subscribed_events(team.space, actor) if is_lead else [])@@ -3161,6 +3166,12 @@ class SessionManager:lines.append(f"New item filed by {event['actor']}: {title}")rows.append({**row, "kind": "filed"})elif event["kind"] == WORKER_WAITING:+ if not is_lead:+ # A collaborator is not an approval authority. Keep the wait+ # informational when it accompanies actual assigned work.+ lines.append(f"{event['actor']} is waiting for the lead or user{(' on ' + title) if item_id is not None else ''}.")+ rows.append({**row, "kind": "waiting", "tool": payload.get("tool") or "", "prompt_id": payload.get("prompt_id", "")})+ continue# §11.6: a worker parked on a tool call under a Manual lead — the lead# decides (its decision asks the human), or the human answers directly.tool = payload.get("tool") or "a tool"@@ -5096,6 +5107,11 @@ 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)."""+ 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)+ if worker_call:+ message = {**message, "data": {**data, "worker_call": worker_call}}for cb in list(self._session_clients.get(session_id, ())):try:await cb(message)@@ -5109,7 +5125,7 @@ class SessionManager:self.audit_store.close()# -- automation (scheduled tasks) -------------------------------------------- def worker_call_for(self, arguments: dict[str, Any]) -> dict[str, Any] | None:+ def worker_call_for(self, arguments: dict[str, Any], *, lead_session: str | None = None) -> dict[str, Any] | None:"""The worker's waiting tool call that a lead's `decide_worker_call` answers(`call_id` is the worker's parked Inbox item). Attached to the lead's approval cardso the human sees WHAT is being allowed or denied, not an id. None when the item is@@ -5117,6 +5133,8 @@ class SessionManager:item = self.inbox.get(str((arguments or {}).get("call_id") or ""))if item is None or item.kind != "approval":return None+ if lead_session is not None and not self._owned_worker_prompt(lead_session, arguments):+ return Nonedata = item.data or {}task_fields = {}found = self.teams.for_worker_session(item.session_id)@@ -5140,6 +5158,12 @@ class SessionManager:"resolution": item.resolution,}+ def _owned_worker_prompt(self, lead_session: str, arguments: dict):+ team = self.teams.for_lead_session(lead_session)+ member = next((w for w in team.workers if w.actor == str(arguments.get("worker") or "").strip().lower()), None) if team else None+ item = self.inbox.get(str(arguments.get("call_id") or ""))+ return item if member and item and item.kind == "approval" and item.session_id == member.session_id else None+def approval_prompt_data(self, session_id: str, request) -> dict[str, Any]:"""Extra Inbox-item payload for a parked approval. Always carries the tool name +arguments so the GUI can render the same humanized card (§35) it shows live —@@ -5154,9 +5178,12 @@ class SessionManager:"arguments": getattr(request, "arguments", None) or {},}if request.tool_name == "decide_worker_call":- worker_call = self.worker_call_for(getattr(request, "arguments", None) or {})+ worker_call = self.worker_call_for(data["arguments"], lead_session=session_id)if worker_call:data["worker_call"] = worker_call+ # Store-owned dependency: atomically retires this redundant gate+ # if the original worker prompt resolves before or after creation.+ data["worker_prompt_id"] = str(data["arguments"]["call_id"])# §35 parity (OPE-136 found-in-testing): the parked card must show the same# scope chip and reason the live card would — carry the tool category, the# MCP destination stamped on the request, and any non-boilerplate reason.@@ -5231,6 +5258,15 @@ class SessionManager:"""from ..engine import ApprovalOutcome+ if resolution == "superseded":+ original = self._owned_worker_prompt(+ session_id, getattr(request, "arguments", None) or {}+ ) if request.tool_name == "decide_worker_call" else None+ return (+ ApprovalOutcome.SUPERSEDED+ if original is not None and original.state == "resolved"+ else ApprovalOutcome.DENY+ )if resolution == "always_task":minted = self.mint_task_rule(session_id,diff --git a/surfaces/gui/e2e/worker-approval.spec.ts b/surfaces/gui/e2e/worker-approval.spec.tsnew file mode 100644index 00000000..38dda6e6--- /dev/null+++ b/surfaces/gui/e2e/worker-approval.spec.ts@@ -0,0 +1,34 @@+import { expect } from "@playwright/test";+import { test } from "./fixtures";++test("a background lead approval shows the command and disappears when the worker request resolves", async ({ page }) => {+ let send: ((event: unknown) => void) | undefined;+ const args = { worker: "maya", call_id: "sample-worker-prompt", decision: "allow", note: "Run the acceptance tests." };+ await page.routeWebSocket("**/ws/session/**", ws => {+ send = event => ws.send(JSON.stringify(event));+ ws.send(JSON.stringify({ type: "ready", data: { running: false, agent: "cowork" } }));+ ws.onMessage(raw => {+ const message = JSON.parse(String(raw));+ if (message.type !== "user_message") return;+ send!({ type: "turn_start", data: {} });+ send!({ type: "tool_proposed", data: { name: "decide_worker_call", arguments: args } });+ send!({ type: "permission_required", data: {+ name: "decide_worker_call", arguments: args, reason: "requires approval", category: "team",+ worker_call: { worker: "maya", tool: "run_shell", arguments: { command: "python -m unittest -v" }, state: "pending" },+ } });+ });+ });+ await page.goto("/");+ await page.getByPlaceholder(/Ask the coworker/).fill("Check the worker approval.");+ await page.getByRole("button", { name: "Send", exact: true }).click();+ await expect(page.getByText("python -m unittest -v", { exact: true })).toBeVisible();+ const allow = page.getByRole("button", { name: "Allow it, as the lead suggests" });+ await expect(allow).toBeVisible();+ // The real server emits this after its linked worker prompt is resolved elsewhere.+ send!({ type: "tool_finished", data: {+ name: "decide_worker_call", status: "ok", superseded_worker_call: "sample-worker-prompt",+ result_preview: '{"skipped":true,"reason":"The worker request was already resolved."}',+ } });+ await expect(allow).toHaveCount(0);+ await expect(page.getByText("The action itself isn’t available here.", { exact: false })).toHaveCount(0);+});diff --git a/surfaces/gui/src/App.tsx b/surfaces/gui/src/App.tsxindex 24498601..5bbd8aff 100644--- a/surfaces/gui/src/App.tsx+++ b/surfaces/gui/src/App.tsx@@ -971,6 +971,14 @@ export function App() {setItems((p) => [...p, questionItemFromPayload(d)]);break;case "tool_finished":+ if (d.superseded_worker_call) {+ // Retire exactly the decision whose worker prompt was answered+ // elsewhere. The tool result remains as the non-action audit receipt.+ setItems(p => p.filter(it => !(it.kind === "approval" &&+ it.name === "decide_worker_call" && it.args?.call_id === d.superseded_worker_call)));+ setSessionInbox(p => p.filter(it => !(it.data?.tool === "decide_worker_call" &&+ it.data?.arguments?.call_id === d.superseded_worker_call)));+ }if (d.display?.team_created?.team_id) {const c = d.display.team_created;setItems(p => [...p, { kind: "teamcreated", teamId: c.team_id, workers: c.workers || [], ts: Date.now() / 1000 }]);diff --git a/surfaces/gui/src/gallery/inboxItems.ts b/surfaces/gui/src/gallery/inboxItems.tsindex 21eae673..886a4d96 100644--- a/surfaces/gui/src/gallery/inboxItems.ts+++ b/surfaces/gui/src/gallery/inboxItems.ts@@ -54,7 +54,7 @@ export const inboxItemBuilders: Partial<Record<string, (s: CardState<any>) => In"approval",`Run \`${p.name}\`?`,`requires approval\nworker: ${p.arguments.worker} · call_id: ${p.arguments.call_id} · decision: ${p.arguments.decision}`,- { tool: p.name, arguments: p.arguments, ...(p.worker_call ? { worker_call: p.worker_call } : {}) },+ { tool: p.name, arguments: p.arguments, ...(p.worker_call ? { worker_call: p.worker_call, worker_prompt_id: p.arguments?.call_id } : {}) },),"connector-request": ({ payload: p }) =>parked(diff --git a/surfaces/gui/src/gallery/states.contract.json b/surfaces/gui/src/gallery/states.contract.jsonindex 0da10fd6..03a5b52f 100644--- a/surfaces/gui/src/gallery/states.contract.json+++ b/surfaces/gui/src/gallery/states.contract.json@@ -12075,7 +12075,8 @@},"reason": "requires approval","state": "pending"- }+ },+ "worker_prompt_id": "c51dc4bd79f74e87b7fc59050dc41c37"}},"lead-allows-command": {@@ -12109,7 +12110,8 @@"description": "Temporarily remove fix, confirm cross-account test fails, then restore"},"state": "pending"- }+ },+ "worker_prompt_id": "c51dc4bd79f74e87b7fc59050dc41c37"}},"lead-denies-file-change": {@@ -12143,7 +12145,8 @@"content": "export async function getInvoices(params: InvoiceQuery) {\n const res = await http.get('/v1/invoices', { params });\n return res.data.invoices;\n}\n"},"state": "pending"- }+ },+ "worker_prompt_id": "c51dc4bd79f74e87b7fc59050dc41c37"}},"already-answered": {@@ -12177,7 +12180,8 @@},"state": "resolved","resolution": "deny"- }+ },+ "worker_prompt_id": "c51dc4bd79f74e87b7fc59050dc41c37"}},"long-note": {@@ -12210,7 +12214,8 @@"command": "set -euo pipefail\ncd /home/user/work/billing-service/issue-1/web\ncurl -fsSL https://example.com/setup-node.sh | bash\nnpm ci\nnpm run build\ncp -r dist ../../issue-3/web/dist\nls -la ../../issue-3/web/dist"},"state": "pending"- }+ },+ "worker_prompt_id": "c51dc4bd79f74e87b7fc59050dc41c37"}},"old-server": {diff --git a/tests/test_gallery_contract.py b/tests/test_gallery_contract.pyindex 0dbc294f..e004ef88 100644--- a/tests/test_gallery_contract.py+++ b/tests/test_gallery_contract.py@@ -172,6 +172,9 @@ def test_question_fields_match_the_gallery(contract):def test_lead_decision_payload_matches_the_gallery(manager, contract):"""`decide_worker_call`: the parked approval carries the worker's call the card shows."""card = contract["worker-decision"]+ from coworker.teams.registry import TeamWorker+ manager.teams.create(space="acme", lead_session="lead-sid", lead_actor="lead",+ workers=[TeamWorker(actor="nia", persona="swe-worker", session_id="worker-sid")])parked = manager.inbox.add_approval("worker-sid", "Run `run_shell`?", body="requires approval\ncommand: npm run build",data={"tool": "run_shell", "arguments": {"command": "npm run build"}},diff --git a/tests/test_team_live_gaps.py b/tests/test_team_live_gaps.pynew file mode 100644index 00000000..85e457f3--- /dev/null+++ b/tests/test_team_live_gaps.py@@ -0,0 +1,206 @@+"""Regressions found by the real lead + two-worker Team View run."""++import asyncio+from types import SimpleNamespace++import pytest+from coworker.engine import ApprovalOutcome, PermissionRequest+from coworker.inbox import InboxStore+from coworker.server.manager import SessionManager+from coworker.sessions import SessionRecord+from coworker.teams.registry import TeamWorker+from coworker.teams.store import WORKER_WAITING+from test_engine import ScriptedProvider, _collect, _engine, _text_turn, _tool_turn+++def manager(tmp_path, monkeypatch):+ monkeypatch.setenv("COWORKER_STATE_DIR", str(tmp_path / "state"))+ (tmp_path / "repo").mkdir()+ m = SessionManager(data_dir=tmp_path / "data", workspace=tmp_path / "repo")+ m.session_store.save(+ SessionRecord(+ session_id="lead",+ workspace=m.default_workspace,+ model="sample",+ mode="interactive",+ agent="swe-lead",+ )+ )+ m.teams.create(+ space=m._board_space("lead"),+ lead_session="lead",+ lead_actor="lead",+ workers=[TeamWorker(actor="sam", persona="swe-worker", session_id="worker")],+ )+ yield m+ asyncio.run(m.aclose())+++def request_for(manager):+ original = manager.inbox.add_approval(+ "worker",+ "Run tests",+ data={"tool": "run_shell", "arguments": {"command": "python -m unittest -v"}},+ )+ request = PermissionRequest(+ tool_name="decide_worker_call",+ arguments={"worker": "sam", "call_id": original.id, "decision": "allow"},+ metadata=None,+ reason="requires approval",+ tool_call_id="lead-call",+ )+ return original, request++[email protected]("resolve_first", [False, True])[email protected]("answer", ["allow", "deny"])+def test_worker_resolution_retires_linked_gate_before_or_after_creation(+ manager, resolve_first, answer+):+ original, request = request_for(manager)+ data = manager.approval_prompt_data("lead", request)+ if resolve_first:+ manager.inbox.resolve(original.id, answer, by="human")++ async def run():+ task = asyncio.create_task(manager.inbox_approver("lead", "swe-lead")(request))+ await asyncio.sleep(0)+ if not resolve_first:+ manager.inbox.resolve(original.id, answer, by="human")+ assert await asyncio.wait_for(task, 1) is ApprovalOutcome.SUPERSEDED++ asyncio.run(run())+ parent = manager.inbox.for_tool_call("lead", "lead-call")+ assert parent.state == "resolved" and parent.resolution == "superseded"+ assert parent.resolved_by == "system:worker-resolution"+ assert parent.data["worker_call"]["state"] == "resolved"+ assert parent.data["worker_call"]["resolution"] == answer+ assert not manager.inbox.pending()+ assert not manager.inbox.resolve(original.id, "opposite")+ assert original.resolution == answer+ loaded = InboxStore(manager.inbox.path)+ assert loaded.get(parent.id).resolution == "superseded"+ assert data["worker_prompt_id"] == original.id+++def test_cross_team_or_mismatched_worker_cannot_link_or_disclose_prompt(manager):+ original, request = request_for(manager)+ assert manager.approval_outcome("superseded", request, "lead") is ApprovalOutcome.DENY+ assert "worker_call" not in manager.approval_prompt_data("not-the-lead", request)+ request.arguments["worker"] = "maya"+ data = manager.approval_prompt_data("lead", request)+ assert "worker_prompt_id" not in data and "worker_call" not in data+ assert original.state == "pending"+++def test_successful_self_wake_ends_turn_without_another_model_call(manager):+ manager.provider = ScriptedProvider([_tool_turn("sleep_for", {"seconds": 2})])+ engine = manager.get_engine("lead", agent="swe-lead")+ events = _collect(engine, "Wait for the worker.")+ assert manager.provider.calls == 1+ assert events[-1].data["status"] == "sleeping"+ assert len(manager.wakes.pending("lead")) == 1+++def test_superseded_gate_never_executes_or_grants_permission(tmp_path):+ async def approve(_):+ return ApprovalOutcome.SUPERSEDED++ engine, _ = _engine(+ tmp_path,+ [+ _tool_turn("write_file", {"path": "must-not-exist.txt", "content": "no"}),+ _text_turn("The original request is already resolved."),+ ],+ approver=approve,+ )+ events = _collect(engine, "write")+ assert not (tmp_path / "must-not-exist.txt").exists()+ finished = [e for e in events if e.type.value == "tool_finished"]+ assert finished[0].data["status"] == "ok"+ assert "already resolved" in finished[0].data["result_preview"]+++def test_background_delivery_enriches_actual_permission_event_and_retires_gate(+ manager, monkeypatch+):+ original, request = request_for(manager)+ manager.provider = ScriptedProvider(+ [+ _tool_turn("decide_worker_call", request.arguments),+ _text_turn("The human already answered the worker."),+ ]+ )+ events = []+ executed = []+ monkeypatch.setattr(manager, "decide_worker_call", lambda *a: executed.append(a))++ async def receive(event):+ events.append(event)++ async def run():+ manager.register_session_client("lead", receive)+ delivery = asyncio.create_task(+ manager.deliver_to_session("lead", "Decide the worker call.")+ )+ for _ in range(200):+ if manager.inbox.pending("lead"):+ break+ await asyncio.sleep(0.01)+ assert manager.inbox.pending("lead")+ manager.inbox.resolve(original.id, "deny", by="human")+ await asyncio.wait_for(delivery, 3)++ asyncio.run(run())+ permission = next(e["data"] for e in events if e["type"] == "permission_required")+ assert permission["worker_call"]["arguments"]["command"] == "python -m unittest -v"+ assert not executed+ assert not manager.inbox.pending()+ assert any(e["type"] == "tool_finished" for e in events)+++def test_lead_self_wake_does_not_enable_general_scheduling(manager):+ lead = manager.get_engine("lead", agent="swe-lead")+ names = set(lead.registry.names())+ assert {"sleep_for", "sleep_until"} <= names+ assert (+ not {"create_scheduled_task", "update_scheduled_task", "delete_scheduled_task"}+ & names+ )+ worker = manager.get_engine(+ "worker", workspace=manager.default_workspace, agent="swe-worker"+ )+ assert "sleep_for" not in worker.registry.names()+++def test_worker_wait_digest_is_informational_and_wait_only_batch_does_not_wake(+ manager, monkeypatch+):+ team = manager.teams.for_lead_session("lead")+ events = [+ {+ "seq": 10,+ "item_id": None,+ "kind": WORKER_WAITING,+ "actor": "maya",+ "payload": {"tool": "run_shell", "prompt_id": "sample-prompt"},+ }+ ]+ body, rows = manager._team_digest(team, events, [], is_lead=False, reader="sam")+ assert "decide_worker_call" not in body and "your decision" not in body+ assert "lead or user" in body and rows[0]["kind"] == "waiting"+ consumed = []+ monkeypatch.setattr(manager.team_store, "feed_for", lambda *a: events)+ monkeypatch.setattr(+ manager.team_store, "consume_feed", lambda *a: consumed.append(a)+ )+ assert (+ asyncio.run(+ manager._drain_team_member(+ team, session_id="worker", actor="sam", is_lead=False+ )+ )+ == 0+ )+ assert consumed == [(team.space, "sam", 10)]diff --git a/tests/test_worker_connectors.py b/tests/test_worker_connectors.pyindex 3ce7cf08..5f7ebc96 100644--- a/tests/test_worker_connectors.py+++ b/tests/test_worker_connectors.py@@ -553,6 +553,9 @@ def test_the_leads_approval_card_carries_the_workers_call(manager):"""The parked approval for `decide_worker_call` shows WHAT the worker wants to run,looked up by call_id — not the id."""_lead(manager)+ from coworker.teams.registry import TeamWorker+ manager.teams.create(space="acme", lead_session="lead-sid", lead_actor="lead",+ workers=[TeamWorker(actor="nia", persona="swe-worker", session_id="worker-sid")])parked = manager.inbox.add_approval("worker-sid", "Run `run_shell`?", body="requires approval\ncommand: npm run build",data={"tool": "run_shell", "arguments": {"command": "npm run build"}},