Skip to content
Python

Fix team approval handoffs and self-wake behavior

Rohit C Prasadf7fcd0d26002
diff --git a/coworker/agent.py b/coworker/agent.py
index 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 time
diff --git a/coworker/engine.py b/coworker/engine.py
index 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:
return
self._cancel.clear()
+ self._yield_for_wake = False
yield Event(EventType.TURN_START, {"input": "(resumed)"})
async for event in self._handle_tool_calls(pending):
yield event
yield 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})
+ return
async for event in self._loop():
yield event
@@ -563,6 +568,7 @@ class TurnEngine:
return []
async def _loop(self) -> AsyncIterator[Event]:
+ self._yield_for_wake = False
iterations = 0
self._continuations = 0
while 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})
+ return
if 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
+ return
if 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 = True
self._step += 1
if status == "ok":
# Only successful calls: a write that raised left nothing on disk to run.
diff --git a/coworker/inbox.py b/coworker/inbox.py
index 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 True
def 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 to
suspend 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.py
index 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 tools
diff --git a/coworker/server/app.py b/coworker/server/app.py
index 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.py
index 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 socket
is 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 card
so 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 None
data = 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.ts
new file mode 100644
index 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.tsx
index 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.ts
index 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.json
index 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.py
index 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.py
new file mode 100644
index 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.py
index 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"}},