heyio 0.1.32 → 0.2.0

package/dist/api/server.js

@@ -5,7 +5,9 @@ import express from "express";
 import { config } from "../config.js";
 import { listSkills } from "../copilot/skills.js";
 import { listSquads, createSquad, listSquadAgents } from "../store/squads.js";
-import { getAgentInfo } from "../copilot/agents.js";
+import { getAgentInfo, cancelAgentTask, getTaskEvents, subscribeToTaskEvents } from "../copilot/agents.js";
+import { abortOrchestrator } from "../copilot/orchestrator.js";
+import { getActiveTasks, getTask, listRecentTasks } from "../store/tasks.js";
 import { IO_VERSION } from "../paths.js";
 import { requireAuth } from "./auth.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -90,7 +92,21 @@ export async function startApiServer() {
         try {
             const slug = Array.isArray(req.params.slug) ? req.params.slug[0] : req.params.slug;
             const agents = listSquadAgents(slug);
-            res.json({ agents });
+            const activeTasks = getActiveTasks();
+            const taskByKey = new Map();
+            for (const t of activeTasks) {
+                taskByKey.set(t.agent_slug, { task_id: t.task_id, description: t.description });
+            }
+            const enriched = agents.map((a) => {
+                const key = `${slug}:${a.character_name}`;
+                const task = taskByKey.get(key) ?? taskByKey.get(slug);
+                return {
+                    ...a,
+                    currentTaskId: task?.task_id ?? null,
+                    currentTask: task?.description ?? null,
+                };
+            });
+            res.json({ agents: enriched });
         }
         catch (e) {
             console.error("Error listing squad agents:", e);
@@ -108,6 +124,93 @@ export async function startApiServer() {
             res.status(500).json({ error: "Failed to list agents" });
         }
     });
+    // Task history endpoints
+    api.get("/tasks", (req, res) => {
+        try {
+            const limitRaw = req.query.limit;
+            const parsed = typeof limitRaw === "string" ? parseInt(limitRaw, 10) : NaN;
+            const limit = Number.isFinite(parsed) && parsed > 0 ? Math.min(parsed, 200) : 50;
+            const tasks = listRecentTasks(limit);
+            res.json({ tasks });
+        }
+        catch (e) {
+            console.error("Error listing tasks:", e);
+            res.status(500).json({ error: "Failed to list tasks" });
+        }
+    });
+    api.get("/tasks/:taskId", (req, res) => {
+        try {
+            const taskId = Array.isArray(req.params.taskId) ? req.params.taskId[0] : req.params.taskId;
+            const task = getTask(taskId);
+            if (!task) {
+                res.status(404).json({ error: "Task not found" });
+                return;
+            }
+            res.json({ task });
+        }
+        catch (e) {
+            console.error("Error fetching task:", e);
+            res.status(500).json({ error: "Failed to fetch task" });
+        }
+    });
+    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");
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Connection", "keep-alive");
+        res.setHeader("X-Accel-Buffering", "no");
+        res.flushHeaders();
+        const send = (ev) => {
+            try {
+                res.write(`data: ${JSON.stringify(ev)}\n\n`);
+            }
+            catch {
+                // client likely disconnected; cleanup happens on req.close
+            }
+        };
+        // Replay buffered events first so a late subscriber sees the full thread
+        for (const ev of getTaskEvents(taskId))
+            send(ev);
+        // Subscribe to live events
+        const unsubscribe = subscribeToTaskEvents(taskId, send);
+        // Heartbeat to keep proxies / browsers from closing the connection
+        const heartbeat = setInterval(() => {
+            try {
+                res.write(": ping\n\n");
+            }
+            catch { /* ignore */ }
+        }, 15000);
+        req.on("close", () => {
+            clearInterval(heartbeat);
+            unsubscribe();
+        });
+    });
+    // Stop / cancel endpoints
+    api.post("/orchestrator/abort", async (_req, res) => {
+        try {
+            const aborted = await abortOrchestrator();
+            res.json({ aborted });
+        }
+        catch (e) {
+            console.error("Error aborting orchestrator:", e);
+            res.status(500).json({ error: "Failed to abort orchestrator" });
+        }
+    });
+    api.post("/tasks/:taskId/cancel", async (req, res) => {
+        try {
+            const taskId = Array.isArray(req.params.taskId) ? req.params.taskId[0] : req.params.taskId;
+            const cancelled = await cancelAgentTask(taskId);
+            if (!cancelled) {
+                res.status(404).json({ error: "Task not found or not running" });
+                return;
+            }
+            res.json({ cancelled: true });
+        }
+        catch (e) {
+            console.error("Error cancelling task:", e);
+            res.status(500).json({ error: "Failed to cancel task" });
+        }
+    });
     // Chat endpoints
     api.post("/message", async (req, res) => {
         const { text } = req.body;
@@ -150,14 +253,25 @@ export async function startApiServer() {
         app.use(express.static(WEB_DIST));
         console.log("[io] Web frontend enabled");
     }
-    // Backward-compat: mount API at / (after static files so HTML/CSS/JS are served first)
-    app.use("/", api);
-    // SPA fallback — serve index.html for any unmatched route
+    // SPA fallback for browser navigation: when the web frontend is built,
+    // serve index.html for any GET request that accepts HTML and isn't an API
+    // call. This lets vue-router handle client-side routes like /chat, /skills,
+    // /squads, etc. on direct URL access and page refresh. Programmatic clients
+    // (curl, fetch without Accept: text/html) fall through to the backward-compat
+    // API mount below.
     if (existsSync(WEB_DIST)) {
-        app.get("/{*splat}", (_req, res) => {
+        app.get(/.*/, (req, res, next) => {
+            if (req.path.startsWith("/api/"))
+                return next();
+            const accept = req.headers.accept ?? "";
+            if (!accept.includes("text/html"))
+                return next();
             res.sendFile(path.join(WEB_DIST, "index.html"));
         });
     }
+    // Backward-compat: mount API at / for non-browser clients (after static files
+    // and SPA fallback so frontend routes are not intercepted).
+    app.use("/", api);
     return new Promise((resolve) => {
         app.listen(config.port, () => {
             console.log(`[io] Server listening on port ${config.port}`);

package/dist/copilot/agents.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "crypto";
+import { EventEmitter } from "events";
 import { execSync } from "child_process";
 import { readFileSync, writeFileSync, readdirSync, statSync, existsSync, mkdirSync, } from "fs";
 import { join, dirname, resolve } from "path";
@@ -6,21 +7,24 @@ import { homedir } from "os";
 import { defineTool, approveAll } from "@github/copilot-sdk";
 import { z } from "zod";
 import { getClient } from "./client.js";
-import { getModelForTask, getModelForTier } from "./model-router.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, } from "../store/tasks.js";
+import { createTask, completeTask, 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
 const agentSessions = new Map();
+const agentSessionModels = new Map();
 function agentSessionKey(squadSlug, characterName) {
     return characterName ? `${squadSlug}:${characterName}` : squadSlug;
 }
 export function getAgentInfo() {
     const activeTasks = getActiveTasks();
     const tasksByAgent = new Map();
+    const taskIdsByAgent = new Map();
     for (const task of activeTasks) {
         tasksByAgent.set(task.agent_slug, task.description);
+        taskIdsByAgent.set(task.agent_slug, task.task_id);
     }
     const agents = [];
     const seenSquads = new Set();
@@ -34,6 +38,7 @@ export function getAgentInfo() {
         if (characterName) {
             const agent = getSquadAgent(squadSlug, characterName);
             const currentTask = tasksByAgent.get(key) ?? tasksByAgent.get(squadSlug);
+            const currentTaskId = taskIdsByAgent.get(key) ?? taskIdsByAgent.get(squadSlug);
             agents.push({
                 slug: squadSlug,
                 name: agent ? `${agent.character_name} (${agent.role_title})` : characterName,
@@ -42,21 +47,61 @@ export function getAgentInfo() {
                 universe: squad?.universe ?? undefined,
                 status: agent?.status === "working" ? "working" : currentTask ? "working" : "idle",
                 currentTask,
+                currentTaskId,
             });
         }
         else {
             // Legacy generic agent
             const currentTask = tasksByAgent.get(squadSlug);
+            const currentTaskId = taskIdsByAgent.get(squadSlug);
             agents.push({
                 slug: squadSlug,
                 name: squad?.name ?? squadSlug,
                 status: currentTask ? "working" : squad?.status === "error" ? "error" : "idle",
                 currentTask,
+                currentTaskId,
             });
         }
     }
     return agents;
 }
+const STREAM_EVENT_TYPES = new Set([
+    "assistant.turn_start",
+    "assistant.intent",
+    "assistant.reasoning",
+    "assistant.reasoning_delta",
+    "assistant.message_delta",
+    "assistant.message",
+    "assistant.turn_end",
+    "tool.execution_start",
+    "tool.execution_progress",
+    "tool.execution_partial_result",
+    "tool.execution_complete",
+    "session.error",
+    "session.warning",
+]);
+const MAX_TASK_EVENTS = 1000;
+const taskEventBuffers = new Map();
+const taskEventEmitter = new EventEmitter();
+taskEventEmitter.setMaxListeners(0);
+function recordTaskEvent(taskId, ev) {
+    let buf = taskEventBuffers.get(taskId);
+    if (!buf) {
+        buf = [];
+        taskEventBuffers.set(taskId, buf);
+    }
+    buf.push(ev);
+    if (buf.length > MAX_TASK_EVENTS)
+        buf.splice(0, buf.length - MAX_TASK_EVENTS);
+    taskEventEmitter.emit(taskId, ev);
+}
+export function getTaskEvents(taskId) {
+    return taskEventBuffers.get(taskId) ?? [];
+}
+export function subscribeToTaskEvents(taskId, listener) {
+    taskEventEmitter.on(taskId, listener);
+    return () => taskEventEmitter.off(taskId, listener);
+}
 export async function delegateToAgent(squadSlug, task, onComplete, targetAgent) {
     const squad = getSquad(squadSlug);
     if (!squad) {
@@ -88,6 +133,22 @@ export async function delegateToAgent(squadSlug, task, onComplete, targetAgent)
     updateSquadStatus(squadSlug, "working");
     if (agent)
         updateAgentStatus(squadSlug, agent.character_name, "working");
+    // Subscribe to the agent session's events for the duration of this task so
+    // the web UI can preview the agent's "thread of consciousness" live.
+    recordTaskEvent(taskId, {
+        ts: Date.now(),
+        type: "task.start",
+        data: { taskId, agentKey, description: task },
+    });
+    const unsubscribe = session.on((event) => {
+        if (!STREAM_EVENT_TYPES.has(event.type))
+            return;
+        recordTaskEvent(taskId, {
+            ts: Date.now(),
+            type: event.type,
+            data: event.data ?? null,
+        });
+    });
     // Run the task in the background — return taskId immediately
     void (async () => {
         try {
@@ -97,6 +158,7 @@ export async function delegateToAgent(squadSlug, task, onComplete, targetAgent)
             updateSquadStatus(squadSlug, "idle");
             if (agent)
                 updateAgentStatus(squadSlug, agent.character_name, "idle");
+            recordTaskEvent(taskId, { ts: Date.now(), type: "task.done", data: { result } });
             onComplete(taskId, result);
         }
         catch (err) {
@@ -105,6 +167,13 @@ export async function delegateToAgent(squadSlug, task, onComplete, targetAgent)
             updateSquadStatus(squadSlug, "error");
             if (agent)
                 updateAgentStatus(squadSlug, agent.character_name, "error");
+            recordTaskEvent(taskId, { ts: Date.now(), type: "task.failed", data: { error: message } });
+        }
+        finally {
+            try {
+                unsubscribe();
+            }
+            catch { /* ignore */ }
         }
     })();
     const agentLabel = agent
@@ -121,6 +190,7 @@ export async function shutdownAgents() {
             // best-effort cleanup
         }
         agentSessions.delete(key);
+        agentSessionModels.delete(key);
     }
 }
 export function getActiveAgentTasks() {
@@ -136,18 +206,38 @@ export function getActiveAgentTasks() {
 // ---------------------------------------------------------------------------
 /**
  * Create or resume a Copilot session for a specific named agent.
- * The system message includes the agent's character personality, role, and charter.
+ * Model is selected per-task: uses the higher of the agent's default tier
+ * and the task's classified complexity. This means an agent never gets a
+ * model worse than their baseline, but can be upgraded for complex tasks.
  */
 async function getOrCreateAgentSession(squadSlug, agent, taskDescription) {
     const key = agentSessionKey(squadSlug, agent.character_name);
+    // Determine model based on task complexity vs agent's default tier
+    const agentTier = agent.model_tier;
+    const taskTier = taskDescription ? classifyComplexity(taskDescription) : agentTier;
+    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
     const existing = agentSessions.get(key);
-    if (existing)
-        return existing;
+    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();
+        }
+        catch { /* best-effort */ }
+        agentSessions.delete(key);
+        agentSessionModels.delete(key);
+    }
     const squad = getSquad(squadSlug);
     const client = await getClient();
     const decisions = getDecisionsSummary(squadSlug);
-    // Resolve model from agent's tier preference
-    const model = getModelForTier(agent.model_tier);
+    console.error(`[io] Agent ${agent.character_name}: using model "${model}" (agent tier: ${agentTier}, task tier: ${taskTier}, effective: ${effectiveTier})`);
     const universeName = squad.universe
         ? getUniverse(squad.universe)?.name ?? squad.universe
         : "Unknown";
@@ -199,6 +289,7 @@ Stay in character — let your personality color your work style and communicati
     }
     updateAgentSession(squadSlug, agent.character_name, session.sessionId);
     agentSessions.set(key, session);
+    agentSessionModels.set(key, model);
     return session;
 }
 /**
@@ -390,4 +481,40 @@ function walkDirectory(dir, maxDepth = 3, depth = 0) {
     }
     return results;
 }
+/**
+ * Cancel a running agent task by aborting its session and marking the task
+ * cancelled. Returns true if the task existed and was running.
+ */
+export async function cancelAgentTask(taskId) {
+    const task = getTask(taskId);
+    if (!task || task.status !== "running")
+        return false;
+    const sessionKey = task.agent_slug;
+    const session = agentSessions.get(sessionKey);
+    if (session) {
+        try {
+            await session.abort();
+        }
+        catch (err) {
+            console.error("[io] Error aborting agent session:", err instanceof Error ? err.message : err);
+        }
+    }
+    cancelTask(taskId);
+    recordTaskEvent(taskId, { ts: Date.now(), type: "task.cancelled", data: { reason: "Cancelled by user" } });
+    // sessionKey is "squadSlug" or "squadSlug:characterName"
+    const [squadSlug, characterName] = sessionKey.split(":");
+    if (squadSlug) {
+        try {
+            updateSquadStatus(squadSlug, "idle");
+        }
+        catch { /* ignore */ }
+    }
+    if (squadSlug && characterName) {
+        try {
+            updateAgentStatus(squadSlug, characterName, "idle");
+        }
+        catch { /* ignore */ }
+    }
+    return true;
+}
 //# sourceMappingURL=agents.js.map

package/dist/copilot/orchestrator.js

@@ -407,4 +407,21 @@ export async function shutdownOrchestrator() {
     clientResetPromise = undefined;
     client = undefined;
 }
+/**
+ * Abort the orchestrator's current in-flight request. The session remains valid
+ * for subsequent prompts. Returns true if a session existed and abort was
+ * attempted, false otherwise.
+ */
+export async function abortOrchestrator() {
+    if (!orchestratorSession)
+        return false;
+    try {
+        await orchestratorSession.abort();
+        return true;
+    }
+    catch (err) {
+        console.error("[io] Error aborting orchestrator session:", err instanceof Error ? err.message : err);
+        return false;
+    }
+}
 //# sourceMappingURL=orchestrator.js.map

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) {

package/dist/store/tasks.js

@@ -29,4 +29,14 @@ 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);
+}
 //# sourceMappingURL=tasks.js.map

package/package.json

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