heyio 0.2.0 → 0.3.0

package/dist/api/server.js

@@ -6,6 +6,7 @@ import { config } from "../config.js";
 import { listSkills } from "../copilot/skills.js";
 import { listSquads, createSquad, listSquadAgents } from "../store/squads.js";
 import { getAgentInfo, cancelAgentTask, getTaskEvents, subscribeToTaskEvents } from "../copilot/agents.js";
+import { summarize, summarizeEvent } from "../copilot/event-summary.js";
 import { abortOrchestrator } from "../copilot/orchestrator.js";
 import { getActiveTasks, getTask, listRecentTasks } from "../store/tasks.js";
 import { IO_VERSION } from "../paths.js";
@@ -153,6 +154,18 @@ export async function startApiServer() {
             res.status(500).json({ error: "Failed to fetch task" });
         }
     });
+    api.get("/tasks/:taskId/activity", (req, res) => {
+        const taskId = Array.isArray(req.params.taskId) ? req.params.taskId[0] : req.params.taskId;
+        try {
+            const events = getTaskEvents(taskId);
+            const activity = summarize(events);
+            res.json({ taskId, activity });
+        }
+        catch (e) {
+            console.error("Error building task activity:", e);
+            res.status(500).json({ error: "Failed to build task activity" });
+        }
+    });
     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");
@@ -162,7 +175,9 @@ export async function startApiServer() {
         res.flushHeaders();
         const send = (ev) => {
             try {
-                res.write(`data: ${JSON.stringify(ev)}\n\n`);
+                const summary = summarizeEvent(ev);
+                const payload = { ...ev, summary };
+                res.write(`data: ${JSON.stringify(payload)}\n\n`);
             }
             catch {
                 // client likely disconnected; cleanup happens on req.close

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
@@ -48,6 +48,7 @@ export function getAgentInfo() {
                 status: agent?.status === "working" ? "working" : currentTask ? "working" : "idle",
                 currentTask,
                 currentTaskId,
+                model: agentSessionModels.get(key),
             });
         }
         else {
@@ -60,6 +61,7 @@ export function getAgentInfo() {
                 status: currentTask ? "working" : squad?.status === "error" ? "error" : "idle",
                 currentTask,
                 currentTaskId,
+                model: agentSessionModels.get(key),
             });
         }
     }
@@ -116,10 +118,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 +168,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 +263,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 +305,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 +392,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 +510,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 +573,208 @@ function walkDirectory(dir, maxDepth = 3, depth = 0) {
     }
     return results;
 }
+/**
+ * Parse APPROVED/REJECTED verdict from a reviewer's free-form response.
+ *
+ * Robust to common formatting variants:
+ *   - Leading blank lines or markdown headers (e.g. "## Review\n\nAPPROVED")
+ *   - Markdown emphasis (e.g. "**APPROVED**")
+ *   - Verdict appearing only later in the response
+ *   - Both tokens appearing in the same line ("I almost said REJECTED but APPROVED")
+ *
+ * Strategy:
+ *   1. Strip markdown noise.
+ *   2. Look at the first 10 non-empty lines for a *line-leading* verdict.
+ *   3. Fall back to the first occurrence of either token anywhere in the body.
+ *   4. If neither token appears, treat as REJECTED (conservative).
+ */
+export function parseReviewVerdict(content) {
+    if (!content)
+        return false;
+    const stripped = content.replace(/[*_`#>]/g, "");
+    const lines = stripped
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter(Boolean)
+        .slice(0, 10);
+    for (const line of lines) {
+        const lead = line
+            .toUpperCase()
+            .match(/^[^A-Z]*\b(APPROVED|REJECTED)\b/);
+        if (lead)
+            return lead[1] === "APPROVED";
+    }
+    const upper = stripped.toUpperCase();
+    const a = upper.search(/\bAPPROVED\b/);
+    const r = upper.search(/\bREJECTED\b/);
+    if (a === -1 && r === -1)
+        return false;
+    if (a === -1)
+        return false;
+    if (r === -1)
+        return true;
+    return a < r;
+}
+/**
+ * Return the reviewer's prose comments with any leading verdict line stripped.
+ * Preserves the original formatting (no upper-casing, no markdown stripping).
+ */
+export function stripLeadingVerdictLine(content) {
+    if (!content)
+        return "";
+    const lines = content.split(/\r?\n/);
+    let i = 0;
+    while (i < lines.length && lines[i].trim() === "")
+        i++;
+    if (i < lines.length) {
+        const probe = lines[i]
+            .replace(/[*_`#>]/g, "")
+            .trim()
+            .toUpperCase();
+        if (/^(APPROVED|REJECTED)\b/.test(probe))
+            i++;
+    }
+    return lines.slice(i).join("\n").trim();
+}
+/**
+ * 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 approved = parseReviewVerdict(content);
+            const comments = stripLeadingVerdictLine(content) || 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,
+                    is_lead: reviewer.is_lead === 1,
+                    approved,
+                    comments,
+                },
+            });
+            reviews.push({
+                reviewer: reviewer.character_name,
+                is_qa: reviewer.is_qa === 1,
+                is_lead: reviewer.is_lead === 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 hasQaReviewers = reviews.some((r) => r.is_qa);
+    const hasLeadReviewer = reviews.some((r) => r.is_lead);
+    const qaRejection = reviews.find((r) => r.is_qa && !r.approved);
+    // Team lead has implicit veto power equivalent to a QA reviewer. If the lead
+    // is also a QA agent the qaRejection branch already covers it; this catches
+    // the lead-but-not-QA case.
+    const leadRejection = reviews.find((r) => r.is_lead && !r.is_qa && !r.approved);
+    const advisoryRejections = reviews.filter((r) => !r.is_qa && !r.is_lead && !r.approved);
+    if (!hasQaReviewers && !hasLeadReviewer && advisoryRejections.length > 0) {
+        recordTaskEvent(taskId, {
+            ts: Date.now(),
+            type: "task.review_advisory",
+            data: {
+                reason: "No QA reviewers or team lead designated; rejections are advisory and do not block promotion.",
+                rejectedBy: advisoryRejections.map((r) => r.reviewer),
+            },
+        });
+    }
+    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 (leadRejection) {
+        recordTaskEvent(taskId, {
+            ts: Date.now(),
+            type: "task.review_complete",
+            data: {
+                promoted: false,
+                reason: `Lead veto from ${leadRejection.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/cron.js

@@ -0,0 +1,136 @@
+// Minimal standard 5-field cron parser + next-run calculator.
+//
+// Fields (in order): minute, hour, day-of-month, month, day-of-week.
+// Supported syntax per field:
+//   *           — all values
+//   N           — single value
+//   A,B,C       — list
+//   A-B         — range
+//   A-B/N or */N — step (A-B/N restricts to range; */N applies to full range)
+//
+// Day-of-week: 0 or 7 = Sunday, 1 = Monday … (standard Unix cron).
+//
+// Matching semantics: when both day-of-month and day-of-week are restricted
+// (i.e. neither is "*"), Vixie cron uses an OR between them — we follow that.
+const FIELD_RANGES = [
+    [0, 59],
+    [0, 23],
+    [1, 31],
+    [1, 12],
+    [0, 7],
+];
+function parseField(raw, [min, max]) {
+    const out = new Set();
+    for (const part of raw.split(",")) {
+        const stepMatch = part.match(/^(.+?)\/(\d+)$/);
+        const body = stepMatch ? stepMatch[1] : part;
+        const step = stepMatch ? parseInt(stepMatch[2], 10) : 1;
+        if (!(step >= 1))
+            throw new Error(`Invalid step in cron field: "${part}"`);
+        let lo, hi;
+        if (body === "*") {
+            lo = min;
+            hi = max;
+        }
+        else if (body.includes("-")) {
+            const [a, b] = body.split("-").map((n) => parseInt(n, 10));
+            if (Number.isNaN(a) || Number.isNaN(b)) {
+                throw new Error(`Invalid range in cron field: "${part}"`);
+            }
+            lo = a;
+            hi = b;
+        }
+        else {
+            const v = parseInt(body, 10);
+            if (Number.isNaN(v))
+                throw new Error(`Invalid cron field value: "${part}"`);
+            lo = v;
+            hi = v;
+        }
+        if (lo < min || hi > max || lo > hi) {
+            throw new Error(`Cron field out of range [${min}-${max}]: "${part}"`);
+        }
+        for (let v = lo; v <= hi; v += step)
+            out.add(v);
+    }
+    return out;
+}
+export function parseCron(expr) {
+    const trimmed = expr.trim().replace(/\s+/g, " ");
+    const parts = trimmed.split(" ");
+    if (parts.length !== 5) {
+        throw new Error(`Cron expression must have 5 fields (minute hour dom month dow), got ${parts.length}: "${expr}"`);
+    }
+    const [mRaw, hRaw, domRaw, monRaw, dowRaw] = parts;
+    const minutes = parseField(mRaw, FIELD_RANGES[0]);
+    const hours = parseField(hRaw, FIELD_RANGES[1]);
+    const doms = parseField(domRaw, FIELD_RANGES[2]);
+    const months = parseField(monRaw, FIELD_RANGES[3]);
+    const dowsRaw = parseField(dowRaw, FIELD_RANGES[4]);
+    const dows = new Set();
+    for (const v of dowsRaw)
+        dows.add(v === 7 ? 0 : v);
+    return {
+        minutes,
+        hours,
+        doms,
+        months,
+        dows,
+        domStar: domRaw === "*",
+        dowStar: dowRaw === "*",
+    };
+}
+/**
+ * Return the next Date strictly after `after` that matches the cron expression.
+ * Iterates minute-by-minute with month/day fast-forwarding. Capped at ~5
+ * years lookahead to guard against unsatisfiable expressions.
+ */
+export function nextRun(expr, after = new Date()) {
+    const c = typeof expr === "string" ? parseCron(expr) : expr;
+    const cursor = new Date(after.getTime());
+    cursor.setSeconds(0, 0);
+    cursor.setMinutes(cursor.getMinutes() + 1);
+    const limit = new Date(after.getTime() + 5 * 366 * 24 * 60 * 60 * 1000);
+    while (cursor <= limit) {
+        const month = cursor.getMonth() + 1;
+        if (!c.months.has(month)) {
+            cursor.setMonth(cursor.getMonth() + 1, 1);
+            cursor.setHours(0, 0, 0, 0);
+            continue;
+        }
+        const dom = cursor.getDate();
+        const dow = cursor.getDay();
+        const dayOk = c.domStar && c.dowStar
+            ? true
+            : c.domStar
+                ? c.dows.has(dow)
+                : c.dowStar
+                    ? c.doms.has(dom)
+                    : c.doms.has(dom) || c.dows.has(dow);
+        if (!dayOk) {
+            cursor.setDate(cursor.getDate() + 1);
+            cursor.setHours(0, 0, 0, 0);
+            continue;
+        }
+        if (!c.hours.has(cursor.getHours())) {
+            cursor.setHours(cursor.getHours() + 1, 0, 0, 0);
+            continue;
+        }
+        if (!c.minutes.has(cursor.getMinutes())) {
+            cursor.setMinutes(cursor.getMinutes() + 1, 0, 0);
+            continue;
+        }
+        return cursor;
+    }
+    throw new Error(`No next run found within 5 years for cron expression`);
+}
+export function validateCron(expr) {
+    try {
+        const next = nextRun(expr);
+        return { ok: true, next };
+    }
+    catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+//# sourceMappingURL=cron.js.map