heyio 1.1.6 → 1.2.0

package/dist/copilot/agents.js

@@ -28,11 +28,22 @@ export async function delegateTask(squadId, task, instanceId) {
         .join("\n");
     const systemMessage = `# Squad Team Lead: ${lead.character_name}
 
-You are ${lead.character_name}, the team lead for this squad. Your role is to:
-1. Break down tasks into smaller pieces
-2. Route work to the appropriate specialist
+You are ${lead.character_name}, the team lead for this squad. Your role is STRICTLY coordination — you do NOT write code, tests, or implementation of any kind.
+
+## Your Responsibilities:
+1. Break down tasks into smaller pieces and delegate to specialists
+2. Route work to the appropriate specialist based on their role
 3. Coordinate reviews and approvals
 4. Ensure quality gates are met
+5. Report progress and blockers
+
+## PROHIBITED — You must NEVER:
+- Write, edit, or generate code directly
+- Create or modify files in the repository
+- Run build/test commands to fix code (only to verify status)
+- Implement any part of a task yourself
+
+If no suitable specialist exists for a sub-task, report that back — do NOT attempt it yourself.
 
 ## Your Team:
 ${agentRoster}
@@ -40,7 +51,7 @@ ${agentRoster}
 ## Workflow Rules:
 - Peer review: QA + Test + Lead have veto power
 - Use \`--comment\` with "LGTM" for approvals (not \`--approve\`)
-- Always pull latest before starting code work
+- Always use the gh CLI for GitHub interactions
 - Merge criteria: all veto-capable members have posted approving comments + CI passes + no conflicts
 
 ${lead.persona ? `## Personality:\n${lead.persona}` : ""}

package/dist/copilot/ceremonies.js

@@ -0,0 +1,155 @@
+import { approveAll } from "@github/copilot-sdk";
+import { getClient } from "./client.js";
+import { getLeadForSquad, getAgentsForSquad } from "../store/squads.js";
+import { selectModel } from "./model-router.js";
+import { postFeedItem } from "../store/feed.js";
+function buildFacilitatorPrompt(lead, agents, task) {
+    const roster = agents
+        .filter((a) => !a.is_lead)
+        .map((a) => `- ${a.character_name} (${a.role_title})${a.is_qa ? " [QA]" : ""}${a.is_test ? " [TEST]" : ""}`)
+        .join("\n");
+    return `# Planning Meeting Facilitator: ${lead.character_name}
+
+You are facilitating a planning meeting for your squad. Your job is to gather input from specialists, then synthesize a clear action plan.
+
+## The Task
+${task}
+
+## Your Team (Specialists)
+${roster}
+
+## Instructions
+For each specialist who is relevant to this task, think about what their domain expertise would contribute. Then synthesize ALL perspectives into a structured plan.
+
+Consider each relevant specialist's likely concerns:
+${agents
+        .filter((a) => !a.is_lead)
+        .map((a) => `- ${a.character_name} (${a.role_title}): What risks, technical suggestions, or constraints would they raise?`)
+        .join("\n")}
+
+## Output Format
+Produce a plan in this exact format:
+
+### Task Summary
+(One sentence summary of what we're building)
+
+### Plan
+(Numbered list of work items with agent assignments)
+
+### Risks & Concerns
+(Bullet list of risks identified, with mitigation strategies)
+
+### Dependencies
+(What must happen in order, what can be parallel)
+
+### Assignments
+(Clear mapping: Agent → what they own)
+
+## Rules
+- You are ONLY planning — do NOT execute any work
+- Assign work to specialists based on their role titles
+- Identify what can be done in parallel vs what has dependencies
+- Flag if any expertise is missing from the team
+${lead.persona ? `\n## Your Style:\n${lead.persona}` : ""}
+`;
+}
+function buildSpecialistPrompt(agent, task) {
+    return `# Planning Input: ${agent.character_name}
+
+You are ${agent.character_name}, a ${agent.role_title}. Your team is planning a new task and needs your expert input.
+
+## The Task
+${task}
+
+## Your Role
+Provide input ONLY from your area of expertise (${agent.role_title}). Be specific and actionable.
+
+## Respond With
+1. **Concerns/Risks**: What could go wrong in your domain?
+2. **Technical Suggestions**: How would you approach your part?
+3. **Dependencies**: What do you need from other team members before you can start?
+4. **Estimated Complexity**: Simple / Moderate / Complex for your portion
+5. **Questions**: Anything unclear that affects your work?
+
+Keep your response focused and concise — this is a planning meeting, not implementation.
+${agent.persona ? `\n## Your Style:\n${agent.persona}` : ""}
+`;
+}
+export async function planningMeeting(squadId, task) {
+    const lead = getLeadForSquad(squadId);
+    if (!lead) {
+        throw new Error("Squad has no team lead. Add a lead agent first.");
+    }
+    const agents = getAgentsForSquad(squadId);
+    const relevantAgents = agents.filter((a) => !a.is_lead);
+    if (relevantAgents.length === 0) {
+        throw new Error("Squad has no specialists to consult. Add agents first.");
+    }
+    const client = await getClient();
+    // Phase 1: Gather specialist input in parallel
+    const specialistInputs = await Promise.allSettled(relevantAgents.map(async (agent) => {
+        const model = await selectModel("low");
+        const session = await client.createSession({
+            model,
+            streaming: true,
+            workingDirectory: process.cwd(),
+            systemMessage: { content: buildSpecialistPrompt(agent, task) },
+            onPermissionRequest: approveAll,
+        });
+        try {
+            const response = await session.sendAndWait({ prompt: "Please provide your planning input for this task." }, 60_000);
+            return {
+                agent: agent.character_name,
+                role: agent.role_title,
+                input: response?.data?.content ?? "(no response)",
+            };
+        }
+        finally {
+            await session.disconnect();
+        }
+    }));
+    // Collect successful inputs
+    const inputs = specialistInputs
+        .filter((r) => r.status === "fulfilled")
+        .map((r) => r.value);
+    const inputsSummary = inputs
+        .map((i) => `### ${i.agent} (${i.role})\n${i.input}`)
+        .join("\n\n");
+    // Phase 2: Lead synthesizes the plan
+    const facilitatorModel = await selectModel("medium");
+    const facilitatorSession = await client.createSession({
+        model: facilitatorModel,
+        streaming: true,
+        workingDirectory: process.cwd(),
+        systemMessage: { content: buildFacilitatorPrompt(lead, agents, task) },
+        onPermissionRequest: approveAll,
+    });
+    let plan;
+    try {
+        const prompt = `Here is the input gathered from your team:\n\n${inputsSummary}\n\nNow synthesize this into a clear, structured action plan.`;
+        const response = await facilitatorSession.sendAndWait({ prompt }, 120_000);
+        plan = response?.data?.content ?? "Planning meeting completed but no plan was produced.";
+    }
+    finally {
+        await facilitatorSession.disconnect();
+    }
+    return {
+        plan,
+        participants: [lead.character_name, ...inputs.map((i) => i.agent)],
+    };
+}
+export async function squadMeeting(squadId, task, executeAfter) {
+    const result = await planningMeeting(squadId, task);
+    const summary = `## Planning Meeting Complete\n\n**Participants:** ${result.participants.join(", ")}\n\n${result.plan}`;
+    if (!executeAfter) {
+        // Post to feed and wait for user to trigger execution
+        postFeedItem(`squad-${squadId}`, "Planning meeting complete — awaiting approval", summary);
+        return summary;
+    }
+    // Execute: delegate with the plan as additional context
+    const { delegateTask } = await import("./agents.js");
+    const enrichedTask = `${task}\n\n---\n## Approved Plan (from team meeting)\n${result.plan}`;
+    const execResult = await delegateTask(squadId, enrichedTask);
+    return `Meeting held, then executed.\n\n${summary}\n\n---\n## Execution Result\n${execResult}`;
+}
+//# sourceMappingURL=ceremonies.js.map

package/dist/copilot/system-message.js

@@ -26,13 +26,19 @@ You are IO, a personal AI assistant daemon. You run 24/7 on the user's machine,
 - Never delegate unless explicitly asked — creating an issue ≠ request to start work
 - When creating squads, research the universe dynamically — never use hardcoded character lists
 - **Always use the gh CLI** for all GitHub interactions (repos, issues, PRs, releases, actions, etc.). Only fall back to the GitHub API or other methods if gh is unavailable or cannot accomplish the task.
+- For complex tasks involving multiple specialists, use squad_meeting to have the team plan together before executing. Use squad_delegate for straightforward single-domain tasks.
+- If the user says "plan this" or "have the team meet" → use squad_meeting with execute_after=false
+- If the user says "do this" for a complex task → use squad_meeting with execute_after=true
+- If the user says "just do it" or it's a simple task → use squad_delegate directly
 
 ## Squad Coverage Requirements
 Every squad MUST have:
-1. A dedicated team lead (PM/Senior Engineer, coordination-only)
+1. A dedicated team lead (PM/Senior Engineer, coordination-only — **never writes code**)
 2. At least one QA reviewer
 3. At least one agent with a test/quality role title
 
+Team leads are strictly managers/delegators/reviewers. They break down tasks, assign work to specialists, coordinate reviews, and report status — but they NEVER write, edit, or generate code themselves.
+
 ## GitHub Self-Review Limitation
 All squad agents share the repo owner's gh identity. GitHub blocks self-approval. Veto reviewers use --comment with "LGTM" instead of --approve. Merge criteria: all veto-capable members have posted approving comments + CI passes + no conflicts.
 ${selfEditBlock}

package/dist/copilot/tools.js

@@ -134,7 +134,7 @@ export function createTools() {
             },
         }),
         defineTool("squad_delegate", {
-            description: "Delegate a task to a squad's team lead. The lead will break it down and route to specialists.",
+            description: "Delegate a task to a squad's team lead. The lead will break it down and route to specialists. Use this for direct execution without a planning meeting.",
             parameters: z.object({
                 squad_id: z.string().describe("Squad ID"),
                 task: z.string().describe("Detailed task description"),
@@ -146,6 +146,20 @@ export function createTools() {
                 return result;
             },
         }),
+        defineTool("squad_meeting", {
+            description: "Trigger a planning meeting for a squad. All relevant specialists provide input before work begins. Use this for complex multi-agent tasks where team input improves the plan. Set execute_after=true to start work immediately after planning, or false to post the plan to the feed for user review.",
+            parameters: z.object({
+                squad_id: z.string().describe("Squad ID"),
+                task: z.string().describe("Detailed task description for the team to plan"),
+                execute_after: z
+                    .boolean()
+                    .describe("If true, execute the plan immediately after the meeting. If false, post plan to feed and wait for user approval."),
+            }),
+            handler: async ({ squad_id, task, execute_after }) => {
+                const { squadMeeting } = await import("./ceremonies.js");
+                return await squadMeeting(squad_id, task, execute_after);
+            },
+        }),
         defineTool("squad_task_status", {
             description: "Check the status of tasks for a squad",
             parameters: z.object({

package/package.json

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