heyio 0.2.1 → 0.4.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

@@ -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),
             });
         }
     }
@@ -238,21 +240,38 @@ async function getOrCreateAgentSession(squadSlug, agent, taskDescription) {
     const tierRank = { high: 3, medium: 2, low: 1 };
     const effectiveTier = tierRank[taskTier] >= tierRank[agentTier] ? taskTier : agentTier;
     const model = getModelForTier(effectiveTier);
-    // If we have a cached session, check if the model matches; if not, destroy and recreate
+    // If we have a cached session, check if the model matches AND the agent
+    // hasn't been left in an error state by a previous task. If either is off,
+    // destroy and recreate. Reusing a session whose underlying SDK process has
+    // been throwing is how Panthro got "stuck" in error after the issue #42
+    // delegation timeout (issue #55).
     const existing = agentSessions.get(key);
     if (existing) {
-        // Sessions don't expose their model, so track it separately
-        const cachedModel = agentSessionModels.get(key);
-        if (cachedModel === model)
-            return existing;
-        // Model changed — destroy old session for the upgraded model
-        console.error(`[io] Agent ${agent.character_name}: upgrading model ${cachedModel} → ${model} for task complexity`);
-        try {
-            await existing.destroy();
+        const fresh = getSquadAgent(squadSlug, agent.character_name);
+        const persistedStatus = fresh?.status ?? agent.status;
+        if (persistedStatus === "error") {
+            console.error(`[io] Agent ${agent.character_name}: previous session ended in error — discarding cached session and recreating`);
+            try {
+                await existing.destroy();
+            }
+            catch { /* best-effort */ }
+            agentSessions.delete(key);
+            agentSessionModels.delete(key);
+        }
+        else {
+            // Sessions don't expose their model, so track it separately
+            const cachedModel = agentSessionModels.get(key);
+            if (cachedModel === model)
+                return existing;
+            // Model changed — destroy old session for the upgraded model
+            console.error(`[io] Agent ${agent.character_name}: upgrading model ${cachedModel} → ${model} for task complexity`);
+            try {
+                await existing.destroy();
+            }
+            catch { /* best-effort */ }
+            agentSessions.delete(key);
+            agentSessionModels.delete(key);
         }
-        catch { /* best-effort */ }
-        agentSessions.delete(key);
-        agentSessionModels.delete(key);
     }
     const squad = getSquad(squadSlug);
     const client = await getClient();
@@ -571,6 +590,69 @@ 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
@@ -605,10 +687,8 @@ Review the work. Respond with:
             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;
+            const approved = parseReviewVerdict(content);
+            const comments = stripLeadingVerdictLine(content) || null;
             createReview(taskId, squadSlug, reviewer.character_name, approved, comments ?? undefined);
             recordTaskEvent(taskId, {
                 ts: Date.now(),
@@ -616,6 +696,7 @@ Review the work. Respond with:
                 data: {
                     reviewer: reviewer.character_name,
                     is_qa: reviewer.is_qa === 1,
+                    is_lead: reviewer.is_lead === 1,
                     approved,
                     comments,
                 },
@@ -623,6 +704,7 @@ Review the work. Respond with:
             reviews.push({
                 reviewer: reviewer.character_name,
                 is_qa: reviewer.is_qa === 1,
+                is_lead: reviewer.is_lead === 1,
                 approved,
                 comments: comments ?? "",
             });
@@ -637,7 +719,24 @@ Review the work. Respond with:
             });
         }
     }
+    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, {
@@ -651,6 +750,18 @@ Review the work. Respond with:
         });
         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(),

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

package/dist/copilot/event-summary.js

@@ -0,0 +1,286 @@
+// Tiered activity log normalizer.
+//
+// Converts raw TaskStreamEvent records (forwarded from the Copilot SDK
+// session) into "activity entries" that present a clean human-readable
+// summary. Each entry preserves the underlying raw payload for drill-down so
+// no information is lost.
+//
+// Used by:
+//   - GET /tasks/:taskId/activity (full collapsed list)
+//   - the SSE per-event payload (single-event summary attached alongside raw)
+//   - the TUI /activity command
+const TOOL_VERBS = {
+    bash: "Ran shell command",
+    shell: "Ran shell command",
+    read_file: "Read file",
+    view: "Read file",
+    create: "Created file",
+    edit: "Edited file",
+    str_replace_editor: "Edited file",
+    grep: "Searched code",
+    glob: "Searched filenames",
+    web_fetch: "Fetched URL",
+    github: "Called GitHub API",
+    delegate_to_teammate: "Delegated to teammate",
+    squad_delegate: "Delegated to squad",
+    squad_status: "Listed squads",
+    squad_agents: "Listed squad agents",
+    squad_set_lead: "Set squad lead",
+    squad_set_qa: "Set squad QA",
+    squad_task_status: "Checked task status",
+    squad_task_reviews: "Read task reviews",
+    squad_log_decision: "Logged squad decision",
+    squad_schedule_create: "Created squad schedule",
+    squad_schedule_list: "Listed squad schedules",
+    squad_schedule_run_now: "Fired squad schedule",
+    wiki_read: "Read wiki page",
+    wiki_write: "Wrote wiki page",
+    wiki_search: "Searched wiki",
+    wiki_list: "Listed wiki pages",
+    skill_list: "Listed skills",
+    skill_install: "Installed skill",
+    skill_remove: "Removed skill",
+    skill_search: "Searched skills registry",
+    config_update: "Updated config",
+    check_update: "Checked for IO update",
+    file_ops: "File operation",
+};
+function trunc(s, n) {
+    if (!s)
+        return "";
+    const flat = s.replace(/\s+/g, " ").trim();
+    return flat.length > n ? flat.slice(0, n - 1) + "…" : flat;
+}
+function pickArgSummary(toolName, args) {
+    if (!args)
+        return "";
+    const a = args;
+    switch (toolName) {
+        case "bash":
+        case "shell": {
+            const cmd = typeof a.command === "string" ? a.command : "";
+            return trunc(cmd, 80);
+        }
+        case "read_file":
+        case "view":
+        case "create":
+        case "edit":
+        case "str_replace_editor": {
+            const p = typeof a.path === "string" ? a.path : (typeof a.file_path === "string" ? a.file_path : "");
+            return p;
+        }
+        case "grep": {
+            const pat = typeof a.pattern === "string" ? `"${trunc(a.pattern, 40)}"` : "";
+            const paths = Array.isArray(a.paths) ? a.paths.join(", ") : (typeof a.paths === "string" ? a.paths : "");
+            return [pat, paths].filter(Boolean).join(" in ");
+        }
+        case "glob": {
+            return typeof a.pattern === "string" ? a.pattern : "";
+        }
+        case "web_fetch": {
+            return typeof a.url === "string" ? a.url : "";
+        }
+        case "delegate_to_teammate": {
+            const teammate = typeof a.teammate === "string" ? a.teammate : "";
+            const task = typeof a.task === "string" ? trunc(a.task, 60) : "";
+            return [teammate, task].filter(Boolean).join(": ");
+        }
+        case "squad_delegate": {
+            const slug = typeof a.slug === "string" ? a.slug : "";
+            const agent = typeof a.agent === "string" ? ` → ${a.agent}` : "";
+            const task = typeof a.task === "string" ? trunc(a.task, 50) : "";
+            return `${slug}${agent}${task ? `: ${task}` : ""}`;
+        }
+        case "wiki_read":
+        case "wiki_write":
+        case "wiki_delete": {
+            return typeof a.path === "string" ? a.path : "";
+        }
+        case "wiki_search":
+        case "skill_search": {
+            return typeof a.query === "string" ? `"${trunc(a.query, 40)}"` : "";
+        }
+        case "github": {
+            const ep = typeof a.endpoint === "string" ? a.endpoint : "";
+            const method = typeof a.method === "string" ? a.method : "";
+            return [method, ep].filter(Boolean).join(" ");
+        }
+        case "file_ops": {
+            const op = typeof a.operation === "string" ? a.operation : "";
+            const p = typeof a.path === "string" ? a.path : "";
+            return [op, p].filter(Boolean).join(" ");
+        }
+        default: {
+            // Best-effort: stringify the first arg value.
+            const k = Object.keys(a)[0];
+            if (!k)
+                return "";
+            const v = a[k];
+            const s = typeof v === "string" ? v : JSON.stringify(v);
+            return `${k}=${trunc(s ?? "", 50)}`;
+        }
+    }
+}
+/** Summarize a single TaskStreamEvent. */
+export function summarizeEvent(ev) {
+    const data = (ev.data ?? {});
+    const base = { ts: ev.ts, rawType: ev.type, raw: ev.data };
+    switch (ev.type) {
+        case "assistant.intent": {
+            const intent = typeof data.intent === "string" ? data.intent : "";
+            return { ...base, kind: "reasoning", icon: "🧠", summary: intent || "(intent)" };
+        }
+        case "assistant.reasoning": {
+            const content = typeof data.content === "string" ? data.content : "";
+            return {
+                ...base,
+                kind: "reasoning",
+                icon: "🧠",
+                summary: trunc(content, 140) || "(reasoning)",
+                detail: content,
+            };
+        }
+        case "assistant.message": {
+            const content = typeof data.content === "string" ? data.content : "";
+            return {
+                ...base,
+                kind: "message",
+                icon: "💬",
+                summary: trunc(content, 200) || "(empty message)",
+                detail: content,
+            };
+        }
+        case "assistant.turn_start":
+            return { ...base, kind: "system", icon: "▶️", summary: "Turn started" };
+        case "assistant.turn_end":
+            return { ...base, kind: "system", icon: "⏹️", summary: "Turn ended" };
+        case "tool.execution_start": {
+            const name = typeof data.toolName === "string" ? data.toolName : "tool";
+            const verb = TOOL_VERBS[name] ?? `Used ${name}`;
+            const args = pickArgSummary(name, data.arguments);
+            return {
+                ...base,
+                kind: "tool",
+                icon: "🔧",
+                summary: args ? `${verb} — ${args}` : verb,
+                toolCallId: typeof data.toolCallId === "string" ? data.toolCallId : undefined,
+                status: "pending",
+            };
+        }
+        case "tool.execution_complete": {
+            const success = data.success === true;
+            const result = (data.result ?? {});
+            const content = typeof result.content === "string" ? result.content : "";
+            return {
+                ...base,
+                kind: "tool",
+                icon: success ? "✅" : "❌",
+                summary: success ? "Tool completed" : "Tool failed",
+                detail: trunc(content, 300),
+                toolCallId: typeof data.toolCallId === "string" ? data.toolCallId : undefined,
+                status: success ? "success" : "error",
+            };
+        }
+        case "tool.execution_progress": {
+            const message = typeof data.message === "string" ? data.message : "";
+            return {
+                ...base,
+                kind: "tool",
+                icon: "⏳",
+                summary: trunc(message, 140) || "Tool progress",
+                toolCallId: typeof data.toolCallId === "string" ? data.toolCallId : undefined,
+                status: "pending",
+            };
+        }
+        case "session.error": {
+            const msg = typeof data.message === "string" ? data.message : (typeof data.error === "string" ? data.error : "");
+            return { ...base, kind: "outcome", icon: "❌", summary: `Error: ${trunc(msg, 160) || "session error"}` };
+        }
+        case "session.warning": {
+            const msg = typeof data.message === "string" ? data.message : "";
+            return { ...base, kind: "outcome", icon: "⚠️", summary: `Warning: ${trunc(msg, 160) || "session warning"}` };
+        }
+        case "task.done": {
+            const r = typeof data.result === "string" ? data.result : "";
+            return { ...base, kind: "outcome", icon: "✅", summary: "Task completed", detail: trunc(r, 300) };
+        }
+        case "task.failed": {
+            const e = typeof data.error === "string" ? data.error : "";
+            return { ...base, kind: "outcome", icon: "❌", summary: `Task failed: ${trunc(e, 160)}` };
+        }
+        case "task.cancelled":
+            return { ...base, kind: "outcome", icon: "🛑", summary: "Task cancelled" };
+        case "task.review":
+            return {
+                ...base,
+                kind: "outcome",
+                icon: data.approved ? "👍" : "👎",
+                summary: `Review by ${data.reviewer ?? "?"}: ${data.approved ? "APPROVED" : "REJECTED"}${data.is_qa ? " (QA)" : ""}`,
+                detail: typeof data.comments === "string" ? data.comments : undefined,
+            };
+        case "task.review_complete":
+            return {
+                ...base,
+                kind: "outcome",
+                icon: data.promoted ? "🚀" : "ℹ️",
+                summary: data.promoted
+                    ? `Promoted PR: ${data.prUrl ?? ""}`
+                    : `Review complete: ${typeof data.reason === "string" ? data.reason : ""}`,
+            };
+        case "task.review_advisory":
+            return {
+                ...base,
+                kind: "outcome",
+                icon: "ℹ️",
+                summary: typeof data.reason === "string" ? data.reason : "Advisory review note",
+            };
+        case "task.review_error": {
+            const e = typeof data.error === "string" ? data.error : "";
+            return { ...base, kind: "outcome", icon: "❌", summary: `Review error: ${trunc(e, 160)}` };
+        }
+        default:
+            return { ...base, kind: "system", icon: "•", summary: ev.type };
+    }
+}
+/**
+ * Collapse a stream of events into the activity log. Tool start + complete
+ * pairs are merged into one entry (success/error and detail attached).
+ * Streaming deltas (assistant.message_delta, assistant.reasoning_delta,
+ * tool.execution_partial_result) are dropped — the "complete" sibling event
+ * is what we summarize.
+ */
+export function summarize(events) {
+    const out = [];
+    const toolIndex = new Map(); // toolCallId → index into out
+    for (const ev of events) {
+        if (ev.type === "assistant.message_delta" ||
+            ev.type === "assistant.reasoning_delta" ||
+            ev.type === "tool.execution_partial_result") {
+            continue;
+        }
+        const entry = summarizeEvent(ev);
+        if (entry.kind === "tool" && entry.toolCallId) {
+            const existing = toolIndex.get(entry.toolCallId);
+            if (existing != null && entry.status && entry.status !== "pending") {
+                // Merge: keep the verb from the start event, add status/detail/icon from completion.
+                const prior = out[existing];
+                out[existing] = {
+                    ...prior,
+                    icon: entry.icon,
+                    status: entry.status,
+                    detail: entry.detail ?? prior.detail,
+                    // Append a brief outcome marker if the start summary is the only descriptor.
+                    summary: prior.summary,
+                    // Keep the completion event raw available for drill-down by stashing on detail when no detail present
+                    raw: { start: prior.raw, complete: entry.raw },
+                    rawType: `${prior.rawType}+${entry.rawType}`,
+                };
+                continue;
+            }
+            toolIndex.set(entry.toolCallId, out.length);
+        }
+        out.push(entry);
+    }
+    return out;
+}
+//# sourceMappingURL=event-summary.js.map