Hotfixes (#293)

* fix(mcp): delegate tool carries the collision surface the B1a gate demands

TASK_AT_DELEGATE (5fc85419) requires intends_to_touch on code delegations,
but the MCP delegate tool never gained the parameter — PMs were rejected
with incomplete_input and could never comply (live fleet-wide delegation
wall, 2026-07-02). Adds intends_to_touch / adds_migration / touches_shared /
depends_on to the tool and forwards them; parity test locks the invariant.

* fix(git): assembly-integrity guard accepts squash-merged children

git cherry patch-matches each child commit individually, so a squash merge
(N patches -> one commit, new patch-id) read as 'work missing' and the #11
guard refused every legitimate submit_up (live 2026-07-02: S6 cell, three
squash-merged children at the branch tip). A parent commit carrying the
child's [taskid8] prefix now proves the child landed; children with no
marker stay flagged — the original incident the guard exists for.

* fix(git): diff head prefers origin when the local ref is behind it

Assembled branches advance on ORIGIN as child PRs squash-merge on GitHub,
but _resolve_head_ref preferred the inspecting clone's parked local ref —
the PR-gate reviewer's evidence diff was built from a pre-merge snapshot
and re-flagged work that had already landed (two false pr_fail verdicts
on the S6 cell PR, live 2026-07-02). When both refs exist and the local
ref is strictly behind origin, resolve to origin/<branch>; local-ahead
(unpushed) and diverged refs keep priority, single-ref cases unchanged.

* test(mcp): plan-gate fields must be tool parameters (parity class lock)

Extends the delegate parity test to every choreographer plan-depth gate:
a gate that can reject with missing=[field] must name only fields the
corresponding MCP tool can send, else the agent can never comply.

* perf(api): wire TaskSummaryResponse into a bounded /tasks/summary route

The panel fetched /api/tasks unbounded and full-fat — 2MB per refresh
measured live (2026-07-02), ~21KB/task, and the trimmed
TaskSummaryResponse was dead code. /tasks/summary returns exactly the
fields list views render (~50x lighter); the status-only branch of
/tasks now honors its limit, and the eleven unbounded task list routes
are capped.

* perf(panel): kill the per-page request flood and fat payloads

Every page load funneled ~85 default-prefetch RSC requests + 665KB of
images + the 2MB task list through the browser's six HTTP/1.1
connections — real data calls queued ~2s before being sent (measured
via Playwright resource timing, 2026-07-02).

- prefetch={false} on all 59 Links (sidebar, task rows, kanban cards,
  list rows) — ~85 requests/refresh down to a handful
- icon/apple-icon/logo resized to render size: 665KB -> 54KB; unused
  219KB PNG removed
- task list fetches the trimmed /tasks/summary (2MB -> ~100KB),
  normalized into the Task shape so list consumers keep their types
- ReactQueryDevtools rendered only in development

* fix(api): Annotated limit defaults so direct-call tests get real ints

Query(...) positional defaults arrive as Query objects when a route
function is invoked outside the HTTP layer (integration tests call
handlers directly) and broke the new [:limit] slices.

* fix(api,panel): summary carries completed_at + board_review_complete

The metrics page computes velocity client-side from completed_at and the
CEO approval queue gates on board_review_complete — both were nulled by
the summary normalizer, so Completed Today/Week read 0 against 63 real
completions and approved-board tasks could vanish from the queue. The
queue also renders quick_context, so it fetches the full list (small,
status-scoped) via tasksApi.listFull instead of the summary.

* fix(runtime): spawn manifest workspace_path follows the task's project

_build_manifest_for_agent hardcoded the roboco project workspace for
every agent; a guard-core task's manifest claimed /data/workspaces/roboco
while the container cwd sat in the task worktree. The manifest now takes
the same _resolve_workspace_cwd the container -w uses — one resolver,
both surfaces agree by construction.

* fix(runtime): respawn breaker catches status ping-pong loops

Any status CHANGE fully reset the strike counter, so a blocked <->
in_progress oscillation — which changes status on every spawn while
advancing nothing — never tripped the gate (live 2026-07-02: 8 spawns
over two hours). A status never seen on the (agent, task) still fully
resets; a REVISITED status gets a bounded reset budget mirroring
tracing_resets, after which strikes accrue and the gate fires.

* fix(runtime): unassigned-QA dispatch spawns without pre-claiming

The transitioning pre-claim moved awaiting_qa -> claimed before the QA
agent existed; the spawned agent's claim_review/pass_review both demand
awaiting_qa, so it bounced twice and unclaimed (live 2026-07-02,
ba7b751c). Matches _spawn_assigned_qa and the external-PR reviewer
dispatch: no pre-claim, the agent claims itself via claim_review.

* fix(tests): narrow await_args before kwargs access (mypy union-attr)

* Minor upgrades

* fix(policy): team-match gate gains org-wide exemption; resume/unblock/activate now team-matched

needs_team_match sat in its permissive fallback since shipping (no
caller supplied Context.agent_team) and three PM verbs opted out
entirely — a misrouted frontend cell PM blocked, escalated, and held a
backend task through exactly that gap (live 2026-07-02). Org-wide roles
(main_pm, board, CEO, PR reviewer) are exempt so escalation handling
and root-PR gating keep working; cell-scoped roles are now enforced
wherever the caller supplies the team.

---------

Co-authored-by: Renn F <rennf93@users.noreply.github.com>

panel/src/lib/api/tasks.ts

@@ -31,8 +31,66 @@ export interface BoardReviewEntry {
   timestamp: string | null;
 }
 
+// Wire shape of GET /tasks/summary (backend TaskSummaryResponse) — exactly
+// the fields list views render; everything fat stays on GET /tasks/{id}.
+interface TaskSummaryWire {
+  id: string;
+  title: string;
+  status: TaskStatus;
+  priority: number;
+  team: Team;
+  assigned_to: string | null;
+  created_at: string;
+  updated_at: string | null;
+  estimated_complexity: Complexity;
+  nature: TaskNature;
+  task_type: TaskType;
+  sequence: number;
+  parent_task_id: string | null;
+  batch_id: string | null;
+  project_id: string | null;
+  product_id: string | null;
+  branch_name: string | null;
+  pr_number: number | null;
+  pr_url: string | null;
+  pr_created: boolean;
+  docs_complete: boolean;
+  completed_at: string | null;
+  board_review_complete: boolean;
+  description_snippet: string | null;
+}
+
+// Normalize a summary into the Task shape so list consumers keep their
+// types. Defaulted fields are never rendered by list views (verified in the
+// 2026-07-02 audit); anything needing them must fetch the full task.
+const summaryToTask = (s: TaskSummaryWire): Task => ({
+  ...s,
+  description: s.description_snippet ?? "",
+  acceptance_criteria: [],
+  created_by: "",
+  dependency_ids: [],
+  blocker_ids: [],
+  claimed_at: null,
+  started_at: null,
+  target_date: null,
+  pm_approvals: {},
+  plan: null,
+  checkpoints: [],
+  progress_updates: [],
+  commits: [],
+  dev_notes: null,
+  qa_notes: null,
+  auditor_notes: null,
+  quick_context: null,
+  self_verified: false,
+  qa_verified: null,
+  sessions: [],
+});
+
 export const tasksApi = {
-  // List tasks with optional filters
+  // List tasks with optional filters — served by the trimmed summary route
+  // (~50x lighter than the full TaskResponse list that measured 2MB and made
+  // every page slow, 2026-07-02). Detail views fetch the full task via get().
   list: async (filters?: TaskFilters): Promise<Task[]> => {
     if (isMockMode()) {
       let tasks = [...mockTasks];
@@ -49,10 +107,31 @@ export const tasksApi = {
     if (filters?.status) params.append("status", filters.status);
     if (filters?.team) params.append("team", filters.team);
     if (filters?.limit) params.append("limit", String(filters.limit));
-    if (filters?.offset) params.append("offset", String(filters.offset));
 
-    const url = "/tasks?" + params.toString();
-    const { data } = await api.get<Task[]>(url);
+    const url = "/tasks/summary?" + params.toString();
+    const { data } = await api.get<TaskSummaryWire[]>(url);
+    return data.map(summaryToTask);
+  },
+
+  // Full-fat list for consumers that render fields beyond the summary
+  // (the CEO approval queue shows quick_context). Hits the heavy /tasks
+  // route — keep the filter narrow and the limit small.
+  listFull: async (filters?: TaskFilters): Promise<Task[]> => {
+    if (isMockMode()) {
+      let tasks = [...mockTasks];
+      if (filters?.status) {
+        tasks = tasks.filter((t) => t.status === filters.status);
+      }
+      if (filters?.team) {
+        tasks = tasks.filter((t) => t.team === filters.team);
+      }
+      return tasks;
+    }
+    const params = new URLSearchParams();
+    if (filters?.status) params.append("status", filters.status);
+    if (filters?.team) params.append("team", filters.team);
+    params.append("limit", String(filters?.limit ?? 100));
+    const { data } = await api.get<Task[]>("/tasks?" + params.toString());
     return data;
   },