heyio 0.1.33 → 0.2.1

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

@@ -74,7 +74,7 @@ export function getSquadAgent(squadSlug, characterName) {
 }
 export function listSquadAgents(squadSlug) {
     return getDb()
-        .prepare("SELECT * FROM squad_agents WHERE squad_slug = ? ORDER BY created_at")
+        .prepare("SELECT * FROM squad_agents WHERE squad_slug = ? ORDER BY id ASC")
         .all(squadSlug);
 }
 export function removeSquadAgent(squadSlug, characterName) {
@@ -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

@@ -29,4 +29,28 @@ export function clearStaleTasks() {
         .prepare("UPDATE agent_tasks SET status = 'failed', result = 'Marked stale on startup', completed_at = CURRENT_TIMESTAMP WHERE status = 'running'")
         .run();
 }
+export function cancelTask(taskId, reason = "Cancelled by user") {
+    getDb()
+        .prepare("UPDATE agent_tasks SET status = 'cancelled', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ? AND status = 'running'")
+        .run(reason, taskId);
+}
+export function listRecentTasks(limit = 50) {
+    return getDb()
+        .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.1.33",
+  "version": "0.2.1",
   "description": "IO — a personal AI assistant built on the GitHub Copilot SDK",
   "bin": {
     "io": "dist/index.js"