heyio 0.2.0 → 0.2.1

package/dist/copilot/agents.js

@@ -8,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, getTask, cancelTask, } 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
@@ -116,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
@@ -159,6 +166,19 @@ export async function delegateToAgent(squadSlug, task, onComplete, targetAgent)
             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) {
@@ -241,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
@@ -256,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.
@@ -343,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,
@@ -461,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)
@@ -481,6 +571,116 @@ 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.

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,

package/dist/copilot/system-message.js

@@ -18,8 +18,8 @@ This restriction does NOT apply to:
 - Any files outside the IO installation directory
 `;
     const squadBlock = opts?.squadRoster
-        ? `\n### Active Squads\n${opts.squadRoster}\n`
-        : "";
+        ? `\n## Active Squads\nThe following squads are available. Route relevant coding requests directly to them.\n\n${opts.squadRoster}\n`
+        : `\n## Active Squads\nNo squads created yet. Use \`squad_create\` to set up a project squad.\n`;
     const osName = process.platform === "darwin" ? "macOS"
         : process.platform === "win32" ? "Windows"
             : "Linux";
@@ -47,12 +47,22 @@ When no source tag is present, assume TUI.
 
 ## Your Role
 
-You receive messages and decide how to handle them:
+You receive messages and decide how to handle them based on a strict routing priority:
 
-- **Direct answer**: For simple questions, general knowledge, status checks — answer directly.
-- **Use tools**: For tasks requiring shell access, file operations, web lookups — use your tools.
-- **Create/delegate to squad**: For coding projects that need persistent context — create a squad with specialized agents.
-- **Use a skill**: If you have a skill for the task, use it.
+### 1. Squad routing (highest priority)
+If **active squads are listed below** and the request is clearly related to one of those projects (coding tasks, bugs, features, issues, PRs, architecture), **delegate immediately to that squad's team lead** using \`squad_delegate\` — do NOT plan the work yourself, do NOT break it into subtasks. Just pass the full request to the lead and let the team handle it internally.
+
+- The team lead will plan and delegate internally to teammates.
+- You do not need to understand the full scope of the work — the lead does.
+- Multiple squads? Pick the one whose \`project_path\` / name best matches the request.
+
+### 2. Direct tools (medium priority)
+For tasks that require shell access, file operations, web lookups, or knowledge base updates — and that are NOT squad project work — use your tools directly. Use a skill if one is available for the task.
+
+### 3. Direct answer (lowest priority)
+For general questions, conversation, status checks, or anything outside the scope of a squad's project — answer directly.
+
+> **Rule**: If a squad exists that covers the topic, always delegate. Never plan or implement squad work yourself.
 ${squadBlock}
 ## Squad System
 
@@ -70,14 +80,24 @@ Squads are persistent project teams with **named specialist agents**. Each squad
 - Check overall status with \`squad_status\`.
 
 ### Delegating Work
-After planning tasks with the user, **use \`squad_delegate\` to send each task to the right agent**:
-1. Plan the work with the user (break into concrete tasks).
-2. Call \`squad_delegate\` with the squad slug and task. Optionally specify an \`agent\` (character name) to target a specific specialist. If omitted, the system picks the best available agent.
-3. The agent works autonomously in the background with their specialized system prompt.
-4. Use \`squad_task_status\` to check progress and retrieve results.
-5. Report results back to the user, mentioning the character name.
-
-You can delegate multiple tasks to different agents in parallel.
+**Do not plan squad work yourself.** When a squad-relevant request arrives:
+1. Call \`squad_delegate\` with the squad slug and the full request (as-is from the user). Do NOT specify an agent — let it route to the team lead automatically.
+2. The team lead breaks it down and delegates to teammates internally via \`delegate_to_teammate\`. If no lead is designated, the system falls back to the first idle agent.
+3. Use \`squad_task_status\` to monitor progress and report results back to the user.
+
+Only specify an \`agent\` when the user **explicitly asks** to target a specific squad member by name.
+
+### Team Leads
+Every squad should have a **team lead**. After building the team with \`squad_add_agent\`, designate one agent as the lead using \`squad_set_lead\`. The lead receives delegated tasks (when no specific agent is targeted), breaks them into subtasks, and assigns work to teammates via the lead-only \`delegate_to_teammate\` tool. This keeps coordination inside the squad rather than forcing IO to micro-manage assignments.
+
+### Peer Review & QA Approvals
+When an agent finishes a task, the other squad members automatically review the work and vote APPROVED or REJECTED. Reviews are recorded and emitted as \`task.review\` events.
+
+- Designate QA reviewers with \`squad_set_qa\` — typically agents focused on testing, security, or quality.
+- **QA agents have veto power**: if any QA reviewer rejects, the PR stays as a draft.
+- Non-QA rejections are advisory — they're recorded but don't block promotion.
+- When all QA approvals pass (or no QA agents exist) and the task result contains a GitHub PR URL, the PR is automatically promoted from draft to ready via \`gh pr ready\`.
+- Use \`squad_task_reviews\` to inspect the reviews on any completed task.
 
 ### Agent Roles Are Dynamic
 **Do NOT use generic roles** like "developer" or "tester". Analyze the project first and create roles that match its actual technology stack. Examples:

package/dist/copilot/tools.js

@@ -111,10 +111,14 @@ export function createTools(deps) {
                     ? UNIVERSES.find((u) => u.id === s.universe)?.name ?? s.universe
                     : "none";
                 const agents = deps.listSquadAgents(s.slug);
+                const lead = deps.getSquadLead(s.slug);
+                const leadLine = lead
+                    ? `\n  ⭐ Team Lead: ${lead.character_name} (${lead.role_title})`
+                    : "";
                 const agentList = agents.length > 0
                     ? "\n  Agents: " + agents.map((a) => `${a.character_name} (${a.role_title})`).join(", ")
                     : "\n  Agents: none — use squad_add_agent to build the team";
-                return `- **${s.name}** (\`${s.slug}\`) — ${s.status} — 🎬 ${universeName}${agentList}\n  📁 ${s.projectPath}`;
+                return `- **${s.name}** (\`${s.slug}\`) — ${s.status} — 🎬 ${universeName}${leadLine}${agentList}\n  📁 ${s.projectPath}`;
             })
                 .join("\n");
         },
@@ -373,7 +377,11 @@ export function createTools(deps) {
             const universeName = squad.universe
                 ? UNIVERSES.find((u) => u.id === squad.universe)?.name ?? squad.universe
                 : "none";
-            const lines = agents.map((a) => `- **${a.character_name}** — ${a.role_title} (${a.model_tier}) — ${a.status}${a.personality ? `\n  _${a.personality}_` : ""}`);
+            const lines = agents.map((a) => {
+                const leadBadge = a.is_lead === 1 ? " ⭐ [LEAD]" : "";
+                const qaBadge = a.is_qa === 1 ? " 🛡️ [QA]" : "";
+                return `- **${a.character_name}**${leadBadge}${qaBadge} — ${a.role_title} (${a.model_tier}) — ${a.status}${a.personality ? `\n  _${a.personality}_` : ""}`;
+            });
             return `**${squad.name}** — 🎬 ${universeName}\n\n${lines.join("\n")}`;
         },
     });
@@ -973,7 +981,84 @@ export function createTools(deps) {
             }
         },
     });
-    return [wikiRead, wikiWrite, wikiSearch, wikiDelete, wikiList, squadCreate, squadRecall, squadStatus, squadLogDecision, squadDelegate, squadTaskStatus, squadDelete, squadAnalyze, squadAddAgent, squadAgents, squadRemoveAgent, skillList, skillInstall, skillRemove, skillSearch, configUpdate, checkUpdate, shell, fileOps, bash, readFile, viewTool, grepTool, strReplaceEditor, github];
+    const squadSetQA = defineTool("squad_set_qa", {
+        description: "Mark a squad agent as a QA reviewer with veto power. QA agents must approve before a PR is promoted from draft to ready.",
+        skipPermission: true,
+        parameters: z.object({
+            slug: z.string().describe("Squad slug"),
+            character_name: z.string().describe("Character name of the agent"),
+            is_qa: z
+                .boolean()
+                .describe("Whether this agent is a QA reviewer (true) or not (false)"),
+        }),
+        handler: async ({ slug, character_name, is_qa }) => {
+            try {
+                const squad = deps.getSquad(slug);
+                if (!squad)
+                    return `Squad not found: ${slug}`;
+                const agents = deps.listSquadAgents(slug);
+                const target = agents.find((a) => a.character_name === character_name);
+                if (!target) {
+                    return `Agent "${character_name}" not found in squad "${slug}".`;
+                }
+                deps.setSquadQA(slug, character_name, is_qa);
+                return is_qa
+                    ? `🛡️ ${character_name} (${target.role_title}) is now a QA reviewer for squad "${squad.name}". They have veto power over PR promotion.`
+                    : `${character_name} is no longer a QA reviewer for squad "${squad.name}".`;
+            }
+            catch (err) {
+                return `Error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+    const squadTaskReviews = defineTool("squad_task_reviews", {
+        description: "Get the peer reviews left on a completed task by the squad. Shows who approved or rejected and any comments.",
+        skipPermission: true,
+        parameters: z.object({
+            task_id: z.string().describe("The task ID to fetch reviews for"),
+        }),
+        handler: async ({ task_id }) => {
+            const reviews = deps.getTaskReviews(task_id);
+            if (reviews.length === 0) {
+                return `No reviews found for task ${task_id}.`;
+            }
+            return reviews
+                .map((r) => {
+                const verdict = r.approved === 1 ? "✅ APPROVED" : "❌ REJECTED";
+                const comments = r.comments ? `\n  ${r.comments.replace(/\n/g, "\n  ")}` : "";
+                return `- **${r.reviewer_character}** — ${verdict}${comments}`;
+            })
+                .join("\n");
+        },
+    });
+    const squadSetLead = defineTool("squad_set_lead", {
+        description: "Designate an agent as the team lead for their squad. The lead receives delegated tasks (when no specific agent is targeted) and orchestrates the team by divvying subtasks to teammates.",
+        skipPermission: true,
+        parameters: z.object({
+            slug: z.string().describe("Squad slug"),
+            character_name: z
+                .string()
+                .describe("Character name of the agent to make team lead"),
+        }),
+        handler: async ({ slug, character_name }) => {
+            try {
+                const squad = deps.getSquad(slug);
+                if (!squad)
+                    return `Squad not found: ${slug}`;
+                const agents = deps.listSquadAgents(slug);
+                const target = agents.find((a) => a.character_name === character_name);
+                if (!target) {
+                    return `Agent "${character_name}" not found in squad "${slug}". Use squad_agents to list the roster.`;
+                }
+                deps.setSquadLead(slug, character_name);
+                return `⭐ ${character_name} (${target.role_title}) is now the team lead for squad "${squad.name}".`;
+            }
+            catch (err) {
+                return `Error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+    return [wikiRead, wikiWrite, wikiSearch, wikiDelete, wikiList, squadCreate, squadRecall, squadStatus, squadLogDecision, squadDelegate, squadTaskStatus, squadDelete, squadAnalyze, squadAddAgent, squadAgents, squadRemoveAgent, squadSetLead, squadSetQA, squadTaskReviews, skillList, skillInstall, skillRemove, skillSearch, configUpdate, checkUpdate, shell, fileOps, bash, readFile, viewTool, grepTool, strReplaceEditor, github];
 }
 function walkDirectory(dir, maxDepth = 3, depth = 0) {
     if (depth >= maxDepth)

package/dist/store/db.js

@@ -70,6 +70,17 @@ export function getDb() {
       status TEXT NOT NULL DEFAULT 'idle',
       created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
       UNIQUE(squad_slug, character_name)
+    )`,
+        `ALTER TABLE squad_agents ADD COLUMN is_lead INTEGER NOT NULL DEFAULT 0`,
+        `ALTER TABLE squad_agents ADD COLUMN is_qa INTEGER NOT NULL DEFAULT 0`,
+        `CREATE TABLE IF NOT EXISTS squad_task_reviews (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      task_id TEXT NOT NULL,
+      squad_slug TEXT NOT NULL,
+      reviewer_character TEXT NOT NULL,
+      approved INTEGER NOT NULL DEFAULT 0,
+      comments TEXT,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
     )`,
     ];
     for (const migration of migrations) {

package/dist/store/squads.js

@@ -115,4 +115,22 @@ export function getDecisionsSummary(squadSlug) {
     })
         .join("\n");
 }
+export function setSquadLead(squadSlug, characterName) {
+    const db = getDb();
+    const tx = db.transaction(() => {
+        db.prepare("UPDATE squad_agents SET is_lead = 0 WHERE squad_slug = ?").run(squadSlug);
+        db.prepare("UPDATE squad_agents SET is_lead = 1 WHERE squad_slug = ? AND character_name = ?").run(squadSlug, characterName);
+    });
+    tx();
+}
+export function getSquadLead(squadSlug) {
+    return getDb()
+        .prepare("SELECT * FROM squad_agents WHERE squad_slug = ? AND is_lead = 1 LIMIT 1")
+        .get(squadSlug);
+}
+export function setSquadQA(squadSlug, characterName, isQA) {
+    getDb()
+        .prepare("UPDATE squad_agents SET is_qa = ? WHERE squad_slug = ? AND character_name = ?")
+        .run(isQA ? 1 : 0, squadSlug, characterName);
+}
 //# sourceMappingURL=squads.js.map

package/dist/store/tasks.js

@@ -39,4 +39,18 @@ export function listRecentTasks(limit = 50) {
         .prepare("SELECT * FROM agent_tasks ORDER BY datetime(started_at) DESC, task_id DESC LIMIT ?")
         .all(limit);
 }
+export function createReview(taskId, squadSlug, reviewerCharacter, approved, comments) {
+    const db = getDb();
+    const info = db
+        .prepare("INSERT INTO squad_task_reviews (task_id, squad_slug, reviewer_character, approved, comments) VALUES (?, ?, ?, ?, ?)")
+        .run(taskId, squadSlug, reviewerCharacter, approved ? 1 : 0, comments ?? null);
+    return db
+        .prepare("SELECT * FROM squad_task_reviews WHERE id = ?")
+        .get(info.lastInsertRowid);
+}
+export function getTaskReviews(taskId) {
+    return getDb()
+        .prepare("SELECT * FROM squad_task_reviews WHERE task_id = ? ORDER BY created_at ASC, id ASC")
+        .all(taskId);
+}
 //# sourceMappingURL=tasks.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heyio",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "IO — a personal AI assistant built on the GitHub Copilot SDK",
   "bin": {
     "io": "dist/index.js"