heyio 0.1.33 → 0.2.1

package/dist/api/server.js

@@ -5,7 +5,9 @@ import express from "express";
 import { config } from "../config.js";
 import { listSkills } from "../copilot/skills.js";
 import { listSquads, createSquad, listSquadAgents } from "../store/squads.js";
-import { getAgentInfo } from "../copilot/agents.js";
+import { getAgentInfo, cancelAgentTask, getTaskEvents, subscribeToTaskEvents } from "../copilot/agents.js";
+import { abortOrchestrator } from "../copilot/orchestrator.js";
+import { getActiveTasks, getTask, listRecentTasks } from "../store/tasks.js";
 import { IO_VERSION } from "../paths.js";
 import { requireAuth } from "./auth.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -90,7 +92,21 @@ export async function startApiServer() {
         try {
             const slug = Array.isArray(req.params.slug) ? req.params.slug[0] : req.params.slug;
             const agents = listSquadAgents(slug);
-            res.json({ agents });
+            const activeTasks = getActiveTasks();
+            const taskByKey = new Map();
+            for (const t of activeTasks) {
+                taskByKey.set(t.agent_slug, { task_id: t.task_id, description: t.description });
+            }
+            const enriched = agents.map((a) => {
+                const key = `${slug}:${a.character_name}`;
+                const task = taskByKey.get(key) ?? taskByKey.get(slug);
+                return {
+                    ...a,
+                    currentTaskId: task?.task_id ?? null,
+                    currentTask: task?.description ?? null,
+                };
+            });
+            res.json({ agents: enriched });
         }
         catch (e) {
             console.error("Error listing squad agents:", e);
@@ -108,6 +124,93 @@ export async function startApiServer() {
             res.status(500).json({ error: "Failed to list agents" });
         }
     });
+    // Task history endpoints
+    api.get("/tasks", (req, res) => {
+        try {
+            const limitRaw = req.query.limit;
+            const parsed = typeof limitRaw === "string" ? parseInt(limitRaw, 10) : NaN;
+            const limit = Number.isFinite(parsed) && parsed > 0 ? Math.min(parsed, 200) : 50;
+            const tasks = listRecentTasks(limit);
+            res.json({ tasks });
+        }
+        catch (e) {
+            console.error("Error listing tasks:", e);
+            res.status(500).json({ error: "Failed to list tasks" });
+        }
+    });
+    api.get("/tasks/:taskId", (req, res) => {
+        try {
+            const taskId = Array.isArray(req.params.taskId) ? req.params.taskId[0] : req.params.taskId;
+            const task = getTask(taskId);
+            if (!task) {
+                res.status(404).json({ error: "Task not found" });
+                return;
+            }
+            res.json({ task });
+        }
+        catch (e) {
+            console.error("Error fetching task:", e);
+            res.status(500).json({ error: "Failed to fetch task" });
+        }
+    });
+    api.get("/tasks/:taskId/events", (req, res) => {
+        const taskId = Array.isArray(req.params.taskId) ? req.params.taskId[0] : req.params.taskId;
+        res.setHeader("Content-Type", "text/event-stream");
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Connection", "keep-alive");
+        res.setHeader("X-Accel-Buffering", "no");
+        res.flushHeaders();
+        const send = (ev) => {
+            try {
+                res.write(`data: ${JSON.stringify(ev)}\n\n`);
+            }
+            catch {
+                // client likely disconnected; cleanup happens on req.close
+            }
+        };
+        // Replay buffered events first so a late subscriber sees the full thread
+        for (const ev of getTaskEvents(taskId))
+            send(ev);
+        // Subscribe to live events
+        const unsubscribe = subscribeToTaskEvents(taskId, send);
+        // Heartbeat to keep proxies / browsers from closing the connection
+        const heartbeat = setInterval(() => {
+            try {
+                res.write(": ping\n\n");
+            }
+            catch { /* ignore */ }
+        }, 15000);
+        req.on("close", () => {
+            clearInterval(heartbeat);
+            unsubscribe();
+        });
+    });
+    // Stop / cancel endpoints
+    api.post("/orchestrator/abort", async (_req, res) => {
+        try {
+            const aborted = await abortOrchestrator();
+            res.json({ aborted });
+        }
+        catch (e) {
+            console.error("Error aborting orchestrator:", e);
+            res.status(500).json({ error: "Failed to abort orchestrator" });
+        }
+    });
+    api.post("/tasks/:taskId/cancel", async (req, res) => {
+        try {
+            const taskId = Array.isArray(req.params.taskId) ? req.params.taskId[0] : req.params.taskId;
+            const cancelled = await cancelAgentTask(taskId);
+            if (!cancelled) {
+                res.status(404).json({ error: "Task not found or not running" });
+                return;
+            }
+            res.json({ cancelled: true });
+        }
+        catch (e) {
+            console.error("Error cancelling task:", e);
+            res.status(500).json({ error: "Failed to cancel task" });
+        }
+    });
     // Chat endpoints
     api.post("/message", async (req, res) => {
         const { text } = req.body;
@@ -150,14 +253,25 @@ export async function startApiServer() {
         app.use(express.static(WEB_DIST));
         console.log("[io] Web frontend enabled");
     }
-    // Backward-compat: mount API at / (after static files so HTML/CSS/JS are served first)
-    app.use("/", api);
-    // SPA fallback — serve index.html for any unmatched route
+    // SPA fallback for browser navigation: when the web frontend is built,
+    // serve index.html for any GET request that accepts HTML and isn't an API
+    // call. This lets vue-router handle client-side routes like /chat, /skills,
+    // /squads, etc. on direct URL access and page refresh. Programmatic clients
+    // (curl, fetch without Accept: text/html) fall through to the backward-compat
+    // API mount below.
     if (existsSync(WEB_DIST)) {
-        app.get("/{*splat}", (_req, res) => {
+        app.get(/.*/, (req, res, next) => {
+            if (req.path.startsWith("/api/"))
+                return next();
+            const accept = req.headers.accept ?? "";
+            if (!accept.includes("text/html"))
+                return next();
             res.sendFile(path.join(WEB_DIST, "index.html"));
         });
     }
+    // Backward-compat: mount API at / for non-browser clients (after static files
+    // and SPA fallback so frontend routes are not intercepted).
+    app.use("/", api);
     return new Promise((resolve) => {
         app.listen(config.port, () => {
             console.log(`[io] Server listening on port ${config.port}`);

package/dist/copilot/agents.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "crypto";
+import { EventEmitter } from "events";
 import { execSync } from "child_process";
 import { readFileSync, writeFileSync, readdirSync, statSync, existsSync, mkdirSync, } from "fs";
 import { join, dirname, resolve } from "path";
@@ -7,8 +8,8 @@ import { defineTool, approveAll } from "@github/copilot-sdk";
 import { z } from "zod";
 import { getClient } from "./client.js";
 import { getModelForTask, getModelForTier, classifyComplexity } from "./model-router.js";
-import { getSquad, updateSquadSession, updateSquadStatus, getDecisionsSummary, logDecision, listSquadAgents, getSquadAgent, updateAgentSession, updateAgentStatus, } from "../store/squads.js";
-import { createTask, completeTask, failTask, getActiveTasks, } from "../store/tasks.js";
+import { getSquad, updateSquadSession, updateSquadStatus, getDecisionsSummary, logDecision, listSquadAgents, getSquadAgent, getSquadLead, updateAgentSession, updateAgentStatus, } from "../store/squads.js";
+import { createTask, completeTask, createReview, failTask, getActiveTasks, getTask, cancelTask, } from "../store/tasks.js";
 import { SESSIONS_DIR } from "../paths.js";
 import { getUniverse } from "./universes.js";
 // Key format: "squadSlug:characterName" for per-agent sessions, "squadSlug" for legacy
@@ -20,8 +21,10 @@ function agentSessionKey(squadSlug, characterName) {
 export function getAgentInfo() {
     const activeTasks = getActiveTasks();
     const tasksByAgent = new Map();
+    const taskIdsByAgent = new Map();
     for (const task of activeTasks) {
         tasksByAgent.set(task.agent_slug, task.description);
+        taskIdsByAgent.set(task.agent_slug, task.task_id);
     }
     const agents = [];
     const seenSquads = new Set();
@@ -35,6 +38,7 @@ export function getAgentInfo() {
         if (characterName) {
             const agent = getSquadAgent(squadSlug, characterName);
             const currentTask = tasksByAgent.get(key) ?? tasksByAgent.get(squadSlug);
+            const currentTaskId = taskIdsByAgent.get(key) ?? taskIdsByAgent.get(squadSlug);
             agents.push({
                 slug: squadSlug,
                 name: agent ? `${agent.character_name} (${agent.role_title})` : characterName,
@@ -43,21 +47,61 @@ export function getAgentInfo() {
                 universe: squad?.universe ?? undefined,
                 status: agent?.status === "working" ? "working" : currentTask ? "working" : "idle",
                 currentTask,
+                currentTaskId,
             });
         }
         else {
             // Legacy generic agent
             const currentTask = tasksByAgent.get(squadSlug);
+            const currentTaskId = taskIdsByAgent.get(squadSlug);
             agents.push({
                 slug: squadSlug,
                 name: squad?.name ?? squadSlug,
                 status: currentTask ? "working" : squad?.status === "error" ? "error" : "idle",
                 currentTask,
+                currentTaskId,
             });
         }
     }
     return agents;
 }
+const STREAM_EVENT_TYPES = new Set([
+    "assistant.turn_start",
+    "assistant.intent",
+    "assistant.reasoning",
+    "assistant.reasoning_delta",
+    "assistant.message_delta",
+    "assistant.message",
+    "assistant.turn_end",
+    "tool.execution_start",
+    "tool.execution_progress",
+    "tool.execution_partial_result",
+    "tool.execution_complete",
+    "session.error",
+    "session.warning",
+]);
+const MAX_TASK_EVENTS = 1000;
+const taskEventBuffers = new Map();
+const taskEventEmitter = new EventEmitter();
+taskEventEmitter.setMaxListeners(0);
+function recordTaskEvent(taskId, ev) {
+    let buf = taskEventBuffers.get(taskId);
+    if (!buf) {
+        buf = [];
+        taskEventBuffers.set(taskId, buf);
+    }
+    buf.push(ev);
+    if (buf.length > MAX_TASK_EVENTS)
+        buf.splice(0, buf.length - MAX_TASK_EVENTS);
+    taskEventEmitter.emit(taskId, ev);
+}
+export function getTaskEvents(taskId) {
+    return taskEventBuffers.get(taskId) ?? [];
+}
+export function subscribeToTaskEvents(taskId, listener) {
+    taskEventEmitter.on(taskId, listener);
+    return () => taskEventEmitter.off(taskId, listener);
+}
 export async function delegateToAgent(squadSlug, task, onComplete, targetAgent) {
     const squad = getSquad(squadSlug);
     if (!squad) {
@@ -72,10 +116,17 @@ export async function delegateToAgent(squadSlug, task, onComplete, targetAgent)
         }
     }
     else {
-        // If squad has named agents, pick the best match (first idle, or first one)
-        const agents = listSquadAgents(squadSlug);
-        if (agents.length > 0) {
-            agent = agents.find((a) => a.status === "idle") ?? agents[0];
+        // Prefer the designated team lead if one exists; otherwise fall back to
+        // the first idle agent (or just the first agent on the roster).
+        const lead = getSquadLead(squadSlug);
+        if (lead) {
+            agent = lead;
+        }
+        else {
+            const agents = listSquadAgents(squadSlug);
+            if (agents.length > 0) {
+                agent = agents.find((a) => a.status === "idle") ?? agents[0];
+            }
         }
     }
     const session = agent
@@ -89,6 +140,22 @@ export async function delegateToAgent(squadSlug, task, onComplete, targetAgent)
     updateSquadStatus(squadSlug, "working");
     if (agent)
         updateAgentStatus(squadSlug, agent.character_name, "working");
+    // Subscribe to the agent session's events for the duration of this task so
+    // the web UI can preview the agent's "thread of consciousness" live.
+    recordTaskEvent(taskId, {
+        ts: Date.now(),
+        type: "task.start",
+        data: { taskId, agentKey, description: task },
+    });
+    const unsubscribe = session.on((event) => {
+        if (!STREAM_EVENT_TYPES.has(event.type))
+            return;
+        recordTaskEvent(taskId, {
+            ts: Date.now(),
+            type: event.type,
+            data: event.data ?? null,
+        });
+    });
     // Run the task in the background — return taskId immediately
     void (async () => {
         try {
@@ -98,6 +165,20 @@ export async function delegateToAgent(squadSlug, task, onComplete, targetAgent)
             updateSquadStatus(squadSlug, "idle");
             if (agent)
                 updateAgentStatus(squadSlug, agent.character_name, "idle");
+            recordTaskEvent(taskId, { ts: Date.now(), type: "task.done", data: { result } });
+            try {
+                await runPeerReview(squadSlug, agent?.character_name ?? "", taskId, task, result);
+            }
+            catch (reviewErr) {
+                console.error("[io] Peer review error:", reviewErr instanceof Error ? reviewErr.message : reviewErr);
+                recordTaskEvent(taskId, {
+                    ts: Date.now(),
+                    type: "task.review_error",
+                    data: {
+                        error: reviewErr instanceof Error ? reviewErr.message : String(reviewErr),
+                    },
+                });
+            }
             onComplete(taskId, result);
         }
         catch (err) {
@@ -106,6 +187,13 @@ export async function delegateToAgent(squadSlug, task, onComplete, targetAgent)
             updateSquadStatus(squadSlug, "error");
             if (agent)
                 updateAgentStatus(squadSlug, agent.character_name, "error");
+            recordTaskEvent(taskId, { ts: Date.now(), type: "task.failed", data: { error: message } });
+        }
+        finally {
+            try {
+                unsubscribe();
+            }
+            catch { /* ignore */ }
         }
     })();
     const agentLabel = agent
@@ -173,7 +261,34 @@ async function getOrCreateAgentSession(squadSlug, agent, taskDescription) {
     const universeName = squad.universe
         ? getUniverse(squad.universe)?.name ?? squad.universe
         : "Unknown";
-    const agentTools = buildAgentTools(squadSlug);
+    const isLead = agent.is_lead === 1;
+    const agentTools = buildAgentTools(squadSlug, isLead);
+    let leadSection = "";
+    if (isLead) {
+        const teammates = listSquadAgents(squadSlug).filter((a) => a.character_name !== agent.character_name);
+        const roster = teammates.length > 0
+            ? teammates
+                .map((t) => {
+                const charter = t.charter
+                    ? t.charter.length > 200
+                        ? t.charter.slice(0, 200) + "…"
+                        : t.charter
+                    : "(no charter)";
+                return `- **${t.character_name}** — ${t.role_title}: ${charter}`;
+            })
+                .join("\n")
+            : "_(no other agents on this squad yet — ask IO to add some)_";
+        leadSection = `
+
+## Team Lead Role
+You are the team lead for this squad. When you receive a task, your job is to:
+1. Break it down into concrete subtasks
+2. Assign each subtask to the most appropriate teammate using the \`delegate_to_teammate\` tool
+3. Collect results and synthesize a final summary
+
+## Your Team
+${roster}`;
+    }
     const systemMessage = `You are ${agent.character_name}, a specialist agent on the "${squad.name}" project team (${universeName} universe).
 
 ## Your Identity
@@ -188,7 +303,7 @@ ${agent.charter ?? "General-purpose agent. Handle tasks as they come."}
 - **Path**: ${squad.project_path}
 
 ## Past Decisions
-${decisions}
+${decisions}${leadSection}
 
 ## Instructions
 You are a coding agent. Use the shell tool to run commands and file_ops to read/write files.
@@ -275,7 +390,7 @@ Log important decisions with squad_log_decision so they persist.`,
     agentSessions.set(squadSlug, session);
     return session;
 }
-function buildAgentTools(squadSlug) {
+function buildAgentTools(squadSlug, isLead = false) {
     const shell = defineTool("shell", {
         description: "Run a shell command. Use for git, build tools, file operations, etc.",
         skipPermission: true,
@@ -393,7 +508,50 @@ function buildAgentTools(squadSlug) {
             }
         },
     });
-    return [shell, fileOps, squadLogDecision];
+    const tools = [shell, fileOps, squadLogDecision];
+    if (isLead) {
+        const delegateToTeammate = defineTool("delegate_to_teammate", {
+            description: "Delegate a subtask to a teammate on this squad. The teammate runs the task synchronously and returns its result. Use this to divvy work as the team lead.",
+            skipPermission: true,
+            parameters: z.object({
+                teammate: z
+                    .string()
+                    .describe("The teammate's character_name (e.g., 'Optimus Prime')"),
+                task: z
+                    .string()
+                    .describe("The concrete task or subtask the teammate should perform"),
+            }),
+            handler: async ({ teammate, task }) => {
+                try {
+                    const teammateAgent = getSquadAgent(squadSlug, teammate);
+                    if (!teammateAgent) {
+                        return `Error: teammate "${teammate}" not found in squad "${squadSlug}". Use squad_agents to list the roster.`;
+                    }
+                    if (teammateAgent.is_lead === 1) {
+                        return `Error: "${teammate}" is the team lead. Delegate to a non-lead teammate.`;
+                    }
+                    updateAgentStatus(squadSlug, teammateAgent.character_name, "working");
+                    try {
+                        const session = await getOrCreateAgentSession(squadSlug, teammateAgent, task);
+                        const response = await session.sendAndWait({ prompt: task }, 300_000);
+                        const result = response?.data?.content ?? "(teammate returned no output)";
+                        updateAgentStatus(squadSlug, teammateAgent.character_name, "idle");
+                        return result;
+                    }
+                    catch (err) {
+                        updateAgentStatus(squadSlug, teammateAgent.character_name, "error");
+                        const message = err instanceof Error ? err.message : String(err);
+                        return `Error from teammate "${teammate}": ${message}`;
+                    }
+                }
+                catch (err) {
+                    return `Error: ${err instanceof Error ? err.message : String(err)}`;
+                }
+            },
+        });
+        tools.push(delegateToTeammate);
+    }
+    return tools;
 }
 function walkDirectory(dir, maxDepth = 3, depth = 0) {
     if (depth >= maxDepth)
@@ -413,4 +571,150 @@ function walkDirectory(dir, maxDepth = 3, depth = 0) {
     }
     return results;
 }
+/**
+ * Run a peer review phase after a task completes. Every other agent on the
+ * squad reviews the work and votes APPROVED / REJECTED. QA agents
+ * (is_qa === 1) have veto power: if any QA agent rejects, the PR is left as
+ * draft. Otherwise, any GitHub PR URL found in the task result is promoted
+ * from draft to ready via `gh pr ready`.
+ */
+async function runPeerReview(squadSlug, originalAgentCharacter, taskId, taskDescription, taskResult) {
+    const reviewers = listSquadAgents(squadSlug).filter((a) => a.character_name !== originalAgentCharacter);
+    if (reviewers.length === 0) {
+        recordTaskEvent(taskId, {
+            ts: Date.now(),
+            type: "task.review_complete",
+            data: { promoted: false, reason: "No other agents to review" },
+        });
+        return;
+    }
+    const reviewPrompt = `You are reviewing the following completed task:
+
+## Task
+${taskDescription}
+
+## Work Done
+${taskResult}
+
+Review the work. Respond with:
+- First line: APPROVED or REJECTED
+- Remaining lines: your review comments`;
+    const reviews = [];
+    for (const reviewer of reviewers) {
+        try {
+            const session = await getOrCreateAgentSession(squadSlug, reviewer, `Peer review of task ${taskId}`);
+            const response = await session.sendAndWait({ prompt: reviewPrompt }, 300_000);
+            const content = response?.data?.content ?? "";
+            const lines = content.split(/\r?\n/);
+            const firstLine = (lines[0] ?? "").trim().toUpperCase();
+            const approved = firstLine.includes("APPROVED") && !firstLine.includes("REJECTED");
+            const comments = lines.slice(1).join("\n").trim() || null;
+            createReview(taskId, squadSlug, reviewer.character_name, approved, comments ?? undefined);
+            recordTaskEvent(taskId, {
+                ts: Date.now(),
+                type: "task.review",
+                data: {
+                    reviewer: reviewer.character_name,
+                    is_qa: reviewer.is_qa === 1,
+                    approved,
+                    comments,
+                },
+            });
+            reviews.push({
+                reviewer: reviewer.character_name,
+                is_qa: reviewer.is_qa === 1,
+                approved,
+                comments: comments ?? "",
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`[io] Reviewer ${reviewer.character_name} failed:`, message);
+            recordTaskEvent(taskId, {
+                ts: Date.now(),
+                type: "task.review_error",
+                data: { reviewer: reviewer.character_name, error: message },
+            });
+        }
+    }
+    const qaRejection = reviews.find((r) => r.is_qa && !r.approved);
+    const prMatch = taskResult.match(/https:\/\/github\.com\/([^/\s]+)\/([^/\s]+)\/pull\/(\d+)/);
+    if (qaRejection) {
+        recordTaskEvent(taskId, {
+            ts: Date.now(),
+            type: "task.review_complete",
+            data: {
+                promoted: false,
+                reason: `QA veto from ${qaRejection.reviewer}`,
+                prUrl: prMatch ? prMatch[0] : null,
+            },
+        });
+        return;
+    }
+    if (!prMatch) {
+        recordTaskEvent(taskId, {
+            ts: Date.now(),
+            type: "task.review_complete",
+            data: { promoted: false, reason: "No PR URL found in task result" },
+        });
+        return;
+    }
+    const [prUrl, owner, repo, prNumber] = prMatch;
+    try {
+        execSync(`gh pr ready ${prNumber} --repo ${owner}/${repo}`, {
+            encoding: "utf-8",
+            timeout: 30_000,
+            env: { ...process.env, HOME: process.env.HOME || homedir() },
+        });
+        recordTaskEvent(taskId, {
+            ts: Date.now(),
+            type: "task.review_complete",
+            data: { promoted: true, prUrl },
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        recordTaskEvent(taskId, {
+            ts: Date.now(),
+            type: "task.review_complete",
+            data: { promoted: false, reason: `gh pr ready failed: ${message}`, prUrl },
+        });
+    }
+}
+/**
+ * Cancel a running agent task by aborting its session and marking the task
+ * cancelled. Returns true if the task existed and was running.
+ */
+export async function cancelAgentTask(taskId) {
+    const task = getTask(taskId);
+    if (!task || task.status !== "running")
+        return false;
+    const sessionKey = task.agent_slug;
+    const session = agentSessions.get(sessionKey);
+    if (session) {
+        try {
+            await session.abort();
+        }
+        catch (err) {
+            console.error("[io] Error aborting agent session:", err instanceof Error ? err.message : err);
+        }
+    }
+    cancelTask(taskId);
+    recordTaskEvent(taskId, { ts: Date.now(), type: "task.cancelled", data: { reason: "Cancelled by user" } });
+    // sessionKey is "squadSlug" or "squadSlug:characterName"
+    const [squadSlug, characterName] = sessionKey.split(":");
+    if (squadSlug) {
+        try {
+            updateSquadStatus(squadSlug, "idle");
+        }
+        catch { /* ignore */ }
+    }
+    if (squadSlug && characterName) {
+        try {
+            updateAgentStatus(squadSlug, characterName, "idle");
+        }
+        catch { /* ignore */ }
+    }
+    return true;
+}
 //# sourceMappingURL=agents.js.map

package/dist/copilot/orchestrator.js

@@ -3,8 +3,8 @@ import { approveAll, } from "@github/copilot-sdk";
 import { config } from "../config.js";
 import { SESSIONS_DIR, IO_VERSION } from "../paths.js";
 import { getState, setState, deleteState, logConversation } from "../store/db.js";
-import { clearStaleTasks, getTask } from "../store/tasks.js";
-import { getSquad, listSquads, createSquad, deleteSquad, logDecision, getDecisionsSummary, updateSquadStatus, addSquadAgent, listSquadAgents, removeSquadAgent, } from "../store/squads.js";
+import { clearStaleTasks, getTask, getTaskReviews } from "../store/tasks.js";
+import { getSquad, listSquads, createSquad, deleteSquad, logDecision, getDecisionsSummary, updateSquadStatus, addSquadAgent, listSquadAgents, removeSquadAgent, setSquadLead, getSquadLead, setSquadQA, } from "../store/squads.js";
 import { readPage, writePage, assertPagePath, deletePage, listPages } from "../wiki/fs.js";
 import { resolveModelTiers } from "./model-router.js";
 import { searchWiki, getWikiSummary } from "../wiki/search.js";
@@ -73,8 +73,23 @@ function getToolDeps() {
             model_tier: a.model_tier,
             personality: a.personality,
             status: a.status,
+            is_lead: a.is_lead,
+            is_qa: a.is_qa,
         })),
         removeSquadAgent,
+        setSquadLead,
+        getSquadLead: (slug) => {
+            const lead = getSquadLead(slug);
+            return lead
+                ? { character_name: lead.character_name, role_title: lead.role_title }
+                : undefined;
+        },
+        setSquadQA,
+        getTaskReviews: (taskId) => getTaskReviews(taskId).map((r) => ({
+            reviewer_character: r.reviewer_character,
+            approved: r.approved,
+            comments: r.comments,
+        })),
         listSkills,
         installSkill,
         removeSkill,
@@ -92,6 +107,30 @@ function toolFingerprint(tools) {
     const names = (tools ?? []).map((t) => t.name).sort().join(",");
     return crypto.createHash("sha256").update(`${IO_VERSION}:${names}`).digest("hex").slice(0, 16);
 }
+function buildSquadRoster() {
+    const squads = listSquads();
+    if (squads.length === 0)
+        return "";
+    return squads
+        .map((s) => {
+        const agents = listSquadAgents(s.slug);
+        const lead = agents.find((a) => a.is_lead === 1);
+        const agentList = agents
+            .map((a) => {
+            const badges = [
+                a.is_lead === 1 ? "⭐ LEAD" : "",
+                a.is_qa === 1 ? "🛡️ QA" : "",
+            ]
+                .filter(Boolean)
+                .join(", ");
+            return `  - ${a.character_name} (${a.role_title})${badges ? ` [${badges}]` : ""}`;
+        })
+            .join("\n");
+        const leadLine = lead ? `\nTeam Lead: ${lead.character_name}` : "";
+        return `**${s.name}** (\`${s.slug}\`) — ${s.status}\n📁 ${s.project_path}${leadLine}\n${agentList || "  _(no agents yet)_"}`;
+    })
+        .join("\n\n");
+}
 function buildFullSessionConfig() {
     const { tools, skillDirectories } = getSessionConfig();
     return {
@@ -102,6 +141,7 @@ function buildFullSessionConfig() {
             content: getOrchestratorSystemMessage({
                 selfEditEnabled: config.selfEditEnabled,
                 memorySummary: getWikiSummary() || undefined,
+                squadRoster: buildSquadRoster() || undefined,
             }),
         },
         tools,
@@ -407,4 +447,21 @@ export async function shutdownOrchestrator() {
     clientResetPromise = undefined;
     client = undefined;
 }
+/**
+ * Abort the orchestrator's current in-flight request. The session remains valid
+ * for subsequent prompts. Returns true if a session existed and abort was
+ * attempted, false otherwise.
+ */
+export async function abortOrchestrator() {
+    if (!orchestratorSession)
+        return false;
+    try {
+        await orchestratorSession.abort();
+        return true;
+    }
+    catch (err) {
+        console.error("[io] Error aborting orchestrator session:", err instanceof Error ? err.message : err);
+        return false;
+    }
+}
 //# sourceMappingURL=orchestrator.js.map