heyio 1.2.4 → 1.4.0

package/dist/api/server.js

@@ -6,14 +6,21 @@ import { loadConfig, saveConfig } from "../config.js";
 import { createAuthMiddleware } from "./auth.js";
 import { sendToOrchestrator } from "../copilot/orchestrator.js";
 import { listSquads, getSquad, getAgentsForSquad } from "../store/squads.js";
-import { getTasksForSquad } from "../store/tasks.js";
-import { getInstancesForSquad } from "../store/instances.js";
+import { getTasksForSquad, getSquadTaskMetrics } from "../store/tasks.js";
+import { getInstancesForSquad, destroyInstance } from "../store/instances.js";
+import { getAgentEvents } from "../store/agent-events.js";
+import { getAuditLog, countAuditLog } from "../store/audit-log.js";
 import { getFeedItems, markFeedItemRead, deleteFeedItem, getUnreadCount, } from "../store/feed.js";
 import { listSchedules, createSchedule, deleteSchedule, toggleSchedule } from "../store/schedules.js";
+import { triggerSchedule } from "../copilot/trigger-schedule.js";
 import { listServers, toggleMcpServer, addMcpServer, removeMcpServer } from "../mcp/index.js";
-import { listSkills, addSkill, removeSkill, getSkillContent, updateSkillContent } from "../copilot/skills.js";
-import { readPage, writePage, deletePage, listPages } from "../wiki/fs.js";
+import { listSkills, addSkill, createSkill, removeSkill, getSkillContent, updateSkillContent, discoverSkills, installFromSource, fetchRemoteSkillPreview } from "../copilot/skills.js";
+import { readPage, writePage, deletePage, listPages, listTemplates, readTemplate, writeTemplate, deleteTemplate } from "../wiki/fs.js";
 import { searchPages } from "../wiki/search.js";
+import { getBacklinks } from "../wiki/backlinks.js";
+import { saveMessage, getConversation, listConversations, searchConversations, deleteConversation, } from "../store/conversations.js";
+import { getTokenUsageSummary, getTokenUsageBySquad, getTokenUsageByAgent, getDailyTokenUsage, } from "../store/token-usage.js";
+import { DEFAULT_MODEL_PRICING } from "../copilot/token-tracker.js";
 import { randomUUID } from "node:crypto";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -57,22 +64,94 @@ export async function startApiServer(config) {
     });
     // --- Chat ---
     app.post("/api/message", async (req, res) => {
-        const { prompt } = req.body;
+        const { prompt, conversationId: clientConvId } = req.body;
         if (!prompt || typeof prompt !== "string") {
             res.status(400).json({ error: "prompt is required" });
             return;
         }
+        const conversationId = (typeof clientConvId === "string" && clientConvId) ? clientConvId : randomUUID();
+        // Persist the user message
+        saveMessage(conversationId, "user", prompt, "web");
         // Stream response via SSE, send final to HTTP response
         await sendToOrchestrator(prompt, "web", (content, done) => {
             broadcast("message_delta", { content, done });
             if (done) {
-                res.json({ content });
+                // Persist the assistant response
+                saveMessage(conversationId, "assistant", content, "web");
+                res.json({ content, conversationId });
             }
         });
     });
+    // --- History ---
+    app.get("/api/history", (req, res) => {
+        const q = req.query.q;
+        const from = req.query.from;
+        const to = req.query.to;
+        const limit = parseInt(req.query.limit) || 50;
+        const offset = parseInt(req.query.offset) || 0;
+        if (q) {
+            res.json(searchConversations(q, { limit, offset, from, to }));
+        }
+        else {
+            res.json(listConversations({ limit, offset, from, to }));
+        }
+    });
+    app.get("/api/history/:id", (req, res) => {
+        const messages = getConversation(req.params.id);
+        if (messages.length === 0) {
+            res.status(404).json({ error: "Conversation not found" });
+            return;
+        }
+        res.json(messages);
+    });
+    app.delete("/api/history/:id", (req, res) => {
+        deleteConversation(req.params.id);
+        res.json({ ok: true });
+    });
     // --- Squads ---
     app.get("/api/squads", (_req, res) => {
-        res.json(listSquads());
+        const data = listSquads();
+        const instanceCounts = {};
+        for (const squad of data.squads) {
+            instanceCounts[squad.id] = getInstancesForSquad(squad.id).length;
+        }
+        res.json({ ...data, instanceCounts });
+    });
+    // --- Squad Health Dashboard ---
+    app.get("/api/squads/health", (_req, res) => {
+        const { squads, agents } = listSquads();
+        const health = squads.map((squad) => {
+            const squadAgents = agents.filter((a) => a.squad_id === squad.id);
+            const instances = getInstancesForSquad(squad.id);
+            const metrics = getSquadTaskMetrics(squad.id);
+            return {
+                id: squad.id,
+                name: squad.name,
+                universe: squad.universe,
+                agentCount: squadAgents.length,
+                activeInstanceCount: instances.length,
+                activeInstances: instances.map((inst) => ({
+                    id: inst.id,
+                    branch: inst.branch,
+                    lastActivity: inst.last_activity,
+                })),
+                tasksTotal: metrics.tasksTotal,
+                tasksCompleted: metrics.tasksCompleted,
+                tasksCompletedRecent: metrics.tasksCompletedRecent,
+                tasksPending: metrics.tasksPending,
+                tasksInProgress: metrics.tasksInProgress,
+                tasksFailed: metrics.tasksFailed,
+                avgCycleTimeMinutes: metrics.avgCycleTimeMinutes,
+                isStalled: metrics.isStalled,
+                recentTasks: metrics.recentTasks.map((t) => ({
+                    id: t.id,
+                    description: t.description,
+                    status: t.status,
+                    updatedAt: t.updated_at,
+                })),
+            };
+        });
+        res.json({ health });
     });
     app.get("/api/squads/:id", (req, res) => {
         const squad = getSquad(req.params.id);
@@ -85,6 +164,50 @@ export async function startApiServer(config) {
         const instances = getInstancesForSquad(req.params.id);
         res.json({ squad, agents, tasks, instances });
     });
+    app.delete("/api/instances/:id", async (req, res) => {
+        try {
+            await destroyInstance(req.params.id);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            const msg = err?.message ?? "Unknown error";
+            const status = msg.toLowerCase().includes("not found") ? 404 : 500;
+            res.status(status).json({ error: msg });
+        }
+    });
+    // --- Task Events ---
+    app.get("/api/tasks/:taskId/events", (req, res) => {
+        const events = getAgentEvents(req.params.taskId);
+        res.json(events);
+    });
+    // --- Stop Task ---
+    app.post("/api/tasks/:taskId/stop", async (req, res) => {
+        try {
+            const { stopTask } = await import("../copilot/agents.js");
+            await stopTask(req.params.taskId);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            const msg = err?.message ?? "Unknown error";
+            const isNotRunning = msg.toLowerCase().includes("not currently running") || msg.toLowerCase().includes("already completed");
+            res.status(isNotRunning ? 404 : 500).json({ error: msg });
+        }
+    });
+    // --- Audit Log ---
+    app.get("/api/audit-log", (req, res) => {
+        const squad_id = req.query.squad_id;
+        const agent_id = req.query.agent_id;
+        const action_type = req.query.action_type;
+        const from = req.query.from;
+        const to = req.query.to;
+        const limit = parseInt(req.query.limit) || 50;
+        const offset = parseInt(req.query.offset) || 0;
+        const filters = { squad_id, agent_id, action_type, from, to, limit, offset };
+        res.json({
+            entries: getAuditLog(filters),
+            total: countAuditLog(filters),
+        });
+    });
     // --- Feed ---
     app.get("/api/feed", (req, res) => {
         const unreadOnly = req.query.unread === "true";
@@ -129,14 +252,62 @@ export async function startApiServer(config) {
         const skills = await listSkills();
         res.json(skills);
     });
+    app.get("/api/skills/discover", async (req, res) => {
+        const source = req.query.source;
+        if (source !== "awesome-copilot" && source !== "skillssh") {
+            res.status(400).json({ error: "source must be 'awesome-copilot' or 'skillssh'" });
+            return;
+        }
+        const q = req.query.q;
+        try {
+            const skills = await discoverSkills(source, q);
+            res.json(skills);
+        }
+        catch (err) {
+            res.status(502).json({ error: err.message });
+        }
+    });
+    app.get("/api/skills/preview", async (req, res) => {
+        const source = req.query.source;
+        const slug = req.query.slug;
+        if (source !== "awesome-copilot" && source !== "skillssh") {
+            res.status(400).json({ error: "source must be 'awesome-copilot' or 'skillssh'" });
+            return;
+        }
+        if (!slug) {
+            res.status(400).json({ error: "slug is required" });
+            return;
+        }
+        try {
+            const content = await fetchRemoteSkillPreview(source, slug);
+            res.json({ content });
+        }
+        catch (err) {
+            res.status(502).json({ error: err.message });
+        }
+    });
     app.post("/api/skills", async (req, res) => {
         try {
-            const { url } = req.body;
-            if (!url || typeof url !== "string") {
-                res.status(400).json({ error: "Missing 'url' in request body" });
+            const { url, source, slug, content } = req.body;
+            if (source && slug) {
+                if (source !== "awesome-copilot" && source !== "skillssh") {
+                    res.status(400).json({ error: "source must be 'awesome-copilot' or 'skillssh'" });
+                    return;
+                }
+                await installFromSource(source, slug);
+            }
+            else if (url && typeof url === "string") {
+                // Git-clone method
+                await addSkill(url);
+            }
+            else if (slug && typeof slug === "string" && content && typeof content === "string") {
+                // Direct-creation method
+                await createSkill(slug, content);
+            }
+            else {
+                res.status(400).json({ error: "Provide 'url' (git clone), 'source' + 'slug' (community install), or 'slug' + 'content' (direct create)" });
                 return;
             }
-            await addSkill(url);
             res.status(201).json({ ok: true });
         }
         catch (err) {
@@ -214,13 +385,66 @@ export async function startApiServer(config) {
         const results = await searchPages(query);
         res.json(results);
     });
+    app.get("/api/wiki/backlinks/*path", async (req, res) => {
+        const raw = req.params.path;
+        const pagePath = Array.isArray(raw) ? raw.join("/") : raw;
+        const backlinks = await getBacklinks(pagePath);
+        res.json(backlinks);
+    });
+    // --- Wiki Templates ---
+    app.get("/api/wiki/templates/squad", async (_req, res) => {
+        const files = await listTemplates();
+        res.json(files);
+    });
+    app.get("/api/wiki/template/squad/*path", async (req, res) => {
+        try {
+            const raw = req.params.path;
+            const templatePath = Array.isArray(raw) ? raw.join("/") : raw;
+            const content = await readTemplate(templatePath);
+            res.json({ path: templatePath, content });
+        }
+        catch (err) {
+            res.status(404).json({ error: err.message });
+        }
+    });
+    app.put("/api/wiki/template/squad/*path", async (req, res) => {
+        const raw = req.params.path;
+        const templatePath = Array.isArray(raw) ? raw.join("/") : raw;
+        const { content } = req.body;
+        await writeTemplate(templatePath, content);
+        res.json({ ok: true });
+    });
+    app.delete("/api/wiki/template/squad/*path", async (req, res) => {
+        try {
+            const raw = req.params.path;
+            const templatePath = Array.isArray(raw) ? raw.join("/") : raw;
+            await deleteTemplate(templatePath);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(404).json({ error: err.message });
+        }
+    });
     // --- Schedules ---
     app.get("/api/schedules", (_req, res) => {
         const type = undefined; // return all
         res.json(listSchedules(type));
     });
     app.post("/api/schedules", (req, res) => {
-        const schedule = createSchedule(req.body);
+        const { type, cron, squad_id, agenda, prompt } = req.body ?? {};
+        if (type !== "squad" && type !== "io") {
+            res.status(400).json({ error: "type must be 'squad' or 'io'" });
+            return;
+        }
+        if (!cron || typeof cron !== "string") {
+            res.status(400).json({ error: "cron is required" });
+            return;
+        }
+        if (!squad_id || typeof squad_id !== "string" || !squad_id.trim()) {
+            res.status(400).json({ error: "squad_id is required" });
+            return;
+        }
+        const schedule = createSchedule({ type, cron, squad_id, agenda, prompt });
         res.json(schedule);
     });
     app.put("/api/schedules/:id", (req, res) => {
@@ -230,6 +454,14 @@ export async function startApiServer(config) {
         }
         res.json({ ok: true });
     });
+    app.post("/api/schedules/:id/trigger", (req, res) => {
+        const schedule = triggerSchedule(req.params.id);
+        if (!schedule) {
+            res.status(404).json({ error: "Schedule not found" });
+            return;
+        }
+        res.json({ ok: true, schedule });
+    });
     app.delete("/api/schedules/:id", (req, res) => {
         deleteSchedule(req.params.id);
         res.json({ ok: true });
@@ -284,6 +516,51 @@ export async function startApiServer(config) {
         saveConfig(updates);
         res.json({ ok: true });
     });
+    // --- Token Usage ---
+    app.get("/api/token-usage/summary", (req, res) => {
+        const since = req.query.since;
+        res.json(getTokenUsageSummary({ since }));
+    });
+    app.get("/api/token-usage/by-squad", (req, res) => {
+        const since = req.query.since;
+        res.json(getTokenUsageBySquad({ since }));
+    });
+    app.get("/api/token-usage/by-agent", (req, res) => {
+        const since = req.query.since;
+        const squadId = req.query.squad_id;
+        res.json(getTokenUsageByAgent({ since, squadId }));
+    });
+    app.get("/api/token-usage/daily", (req, res) => {
+        const days = parseInt(req.query.days) || 30;
+        res.json(getDailyTokenUsage(days));
+    });
+    app.get("/api/token-usage/pricing", (_req, res) => {
+        const config = loadConfig();
+        const merged = { ...DEFAULT_MODEL_PRICING, ...(config.modelPricing ?? {}) };
+        res.json(merged);
+    });
+    app.put("/api/token-usage/pricing", (req, res) => {
+        const pricing = req.body;
+        if (typeof pricing !== "object" || pricing === null) {
+            res.status(400).json({ error: "Expected object body" });
+            return;
+        }
+        saveConfig({ modelPricing: pricing });
+        res.json({ ok: true });
+    });
+    app.get("/api/token-usage/alert-threshold", (_req, res) => {
+        const config = loadConfig();
+        res.json({ tokenAlertThreshold: config.tokenAlertThreshold ?? null });
+    });
+    app.put("/api/token-usage/alert-threshold", (req, res) => {
+        const { tokenAlertThreshold } = req.body;
+        if (tokenAlertThreshold !== null && typeof tokenAlertThreshold !== "number") {
+            res.status(400).json({ error: "tokenAlertThreshold must be a number or null" });
+            return;
+        }
+        saveConfig({ tokenAlertThreshold: tokenAlertThreshold ?? undefined });
+        res.json({ ok: true });
+    });
     // --- Health (unauthenticated) ---
     app.get("/health", (_req, res) => {
         res.json({ status: "ok", version: process.env.npm_package_version ?? "unknown" });

package/dist/config.js

@@ -2,6 +2,10 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 import { z } from "zod";
 import { PATHS } from "./paths.js";
+const ModelPriceSchema = z.object({
+    inputPer1M: z.number(),
+    outputPer1M: z.number(),
+});
 const ConfigSchema = z.object({
     telegramBotToken: z.string().optional(),
     authorizedUserId: z.number().optional(),
@@ -17,6 +21,8 @@ const ConfigSchema = z.object({
         .default("meaningful"),
     backgroundNotifyTelegram: z.boolean().default(true),
     watchdogEnabled: z.boolean().default(true),
+    modelPricing: z.record(z.string(), ModelPriceSchema).optional(),
+    tokenAlertThreshold: z.number().optional(),
 });
 let cachedConfig;
 export function loadConfig() {

package/dist/copilot/agents.js

@@ -1,15 +1,47 @@
 import { approveAll } from "@github/copilot-sdk";
 import { getClient } from "./client.js";
-import { getLeadForSquad, getAgentsForSquad, updateAgentStatus } from "../store/squads.js";
-import { createTask, updateTaskStatus } from "../store/tasks.js";
+import { getLeadForSquad, getAgentsForSquad, updateAgentStatus, getSquad } from "../store/squads.js";
+import { createTask, updateTaskStatus, getTask } from "../store/tasks.js";
 import { touchInstanceActivity } from "../store/instances.js";
 import { selectModel, classifyComplexity } from "./model-router.js";
 import { postFeedItem } from "../store/feed.js";
+import { attachTokenTracker } from "./token-tracker.js";
+import { addAuditEntry } from "../store/audit-log.js";
+import { addAgentEvent } from "../store/agent-events.js";
+import { createSquadTools } from "./squad-tools.js";
+import { loadSkillDirectories } from "./skills.js";
+import { getMcpServersForSession } from "../mcp/registry.js";
+// Registry of active agent sessions keyed by task ID
+const activeSessions = new Map();
+/**
+ * Stop a running agent by task ID. Disconnects the session and marks the task as stopped.
+ */
+export async function stopTask(taskId) {
+    const session = activeSessions.get(taskId);
+    if (!session) {
+        throw new Error(`Task is not currently running or has already completed`);
+    }
+    try {
+        await session.disconnect();
+    }
+    finally {
+        activeSessions.delete(taskId);
+    }
+    updateTaskStatus(taskId, "stopped", "Stopped by user");
+    addAgentEvent(taskId, "status", "Task stopped by user", { reason: "user_requested" });
+    // Reset agent status to idle
+    const task = getTask(taskId);
+    if (task?.agent_id) {
+        updateAgentStatus(task.agent_id, "idle");
+    }
+}
 export async function delegateTask(squadId, task, instanceId) {
     const lead = getLeadForSquad(squadId);
     if (!lead) {
         throw new Error("Squad has no team lead. Add a lead agent first.");
     }
+    const squad = getSquad(squadId);
+    const squadSlug = squad?.slug ?? squadId;
     const agents = getAgentsForSquad(squadId);
     const taskRecord = createTask(squadId, task, instanceId, lead.id);
     // Update lead status
@@ -21,6 +53,8 @@ export async function delegateTask(squadId, task, instanceId) {
     // Select model based on task complexity
     const tier = classifyComplexity(task);
     const model = await selectModel(tier);
+    // Audit: task delegated
+    addAuditEntry("task_delegated", `Task delegated to ${lead.character_name} (${lead.role_title})`, { task: task.slice(0, 500), model }, { squad_id: squadId, agent_id: lead.id, task_id: taskRecord.id });
     // Create ephemeral agent session for the lead
     const client = await getClient();
     const agentRoster = agents
@@ -58,11 +92,18 @@ ${lead.persona ? `## Personality:\n${lead.persona}` : ""}
 `;
     let result;
     try {
+        // Load squad-scoped tools, skills, and MCP servers
+        const squadTools = createSquadTools(squadSlug, squadId);
+        const skillDirs = await loadSkillDirectories();
+        const mcpServers = getMcpServersForSession();
         const session = await client.createSession({
             model,
             streaming: true,
             workingDirectory: process.cwd(),
             systemMessage: { content: systemMessage },
+            tools: squadTools,
+            skillDirectories: skillDirs,
+            mcpServers,
             onPermissionRequest: approveAll,
             infiniteSessions: {
                 enabled: true,
@@ -70,25 +111,79 @@ ${lead.persona ? `## Personality:\n${lead.persona}` : ""}
                 bufferExhaustionThreshold: 0.95,
             },
         });
+        // Register session so it can be stopped externally
+        activeSessions.set(taskRecord.id, session);
+        const flushTokens = attachTokenTracker(session, {
+            squadId,
+            agentId: lead.id,
+            taskId: taskRecord.id,
+        });
         try {
-            const response = await session.sendAndWait({ prompt: `Task delegated to you:\n\n${task}` }, 600_000);
-            result = response?.data?.content ?? "Task completed (no response content).";
+            // Mark task as in progress and record start event
+            updateTaskStatus(taskRecord.id, "in_progress");
+            addAgentEvent(taskRecord.id, "status", `Task started by ${lead.character_name}`, {
+                agent: lead.character_name,
+                role: lead.role_title,
+                task,
+            });
+            // Capture streaming message deltas and broadcast via SSE
+            let accumulatedMessage = "";
+            const { broadcast } = await import("../api/server.js");
+            const unsubscribeDelta = session.on("assistant.message_delta", (event) => {
+                const delta = event.data?.deltaContent ?? "";
+                if (delta) {
+                    accumulatedMessage += delta;
+                    broadcast("agent_event", {
+                        taskId: taskRecord.id,
+                        type: "message_delta",
+                        summary: accumulatedMessage,
+                        payload: { delta, accumulated: accumulatedMessage },
+                    });
+                }
+            });
+            try {
+                const response = await session.sendAndWait({ prompt: `Task delegated to you:\n\n${task}` }, 600_000);
+                result = response?.data?.content ?? "Task completed (no response content).";
+                // Record the final message event if we have meaningful content
+                if (accumulatedMessage.trim()) {
+                    addAgentEvent(taskRecord.id, "message", accumulatedMessage, {
+                        agent: lead.character_name,
+                        content: accumulatedMessage,
+                    });
+                }
+            }
+            finally {
+                unsubscribeDelta();
+            }
         }
         finally {
+            activeSessions.delete(taskRecord.id);
+            flushTokens();
             await session.disconnect();
         }
     }
     catch (err) {
         const errMsg = err instanceof Error ? err.message : "Unknown error";
+        addAgentEvent(taskRecord.id, "status", `Task failed: ${errMsg}`, { error: errMsg });
         updateTaskStatus(taskRecord.id, "failed", errMsg);
         updateAgentStatus(lead.id, "idle");
+        // Audit: task failed
+        addAuditEntry("task_failed", `Task failed: ${errMsg.slice(0, 200)}`, { error: errMsg }, { squad_id: squadId, agent_id: lead.id, task_id: taskRecord.id });
         throw err;
     }
     // Update task and agent status
     updateTaskStatus(taskRecord.id, "done", result);
     updateAgentStatus(lead.id, "idle");
+    // Audit: task completed
+    addAuditEntry("task_completed", `Task completed by ${lead.character_name}`, { result: result.slice(0, 500) }, { squad_id: squadId, agent_id: lead.id, task_id: taskRecord.id });
+    // Record completion event
+    addAgentEvent(taskRecord.id, "status", `Task completed by ${lead.character_name}`, {
+        agent: lead.character_name,
+        result: result.slice(0, 500),
+    });
     // Post to feed
-    postFeedItem(`squad-${squadId}`, `Task completed by ${lead.character_name}`, result.slice(0, 2000));
+    const squadSource = `squad-${squadSlug}`;
+    postFeedItem(squadSource, `Task completed by ${lead.character_name}`, result.slice(0, 2000));
     return result;
 }
 //# sourceMappingURL=agents.js.map

package/dist/copilot/ceremonies.js

@@ -1,8 +1,9 @@
 import { approveAll } from "@github/copilot-sdk";
 import { getClient } from "./client.js";
-import { getLeadForSquad, getAgentsForSquad } from "../store/squads.js";
+import { getLeadForSquad, getAgentsForSquad, getSquad } from "../store/squads.js";
 import { selectModel } from "./model-router.js";
 import { postFeedItem } from "../store/feed.js";
+import { attachTokenTracker } from "./token-tracker.js";
 function buildFacilitatorPrompt(lead, agents, task) {
     const roster = agents
         .filter((a) => !a.is_lead)
@@ -96,6 +97,7 @@ export async function planningMeeting(squadId, task) {
             systemMessage: { content: buildSpecialistPrompt(agent, task) },
             onPermissionRequest: approveAll,
         });
+        const flushTokens = attachTokenTracker(session, { squadId, agentId: agent.id });
         try {
             const response = await session.sendAndWait({ prompt: "Please provide your planning input for this task." }, 60_000);
             return {
@@ -105,6 +107,7 @@ export async function planningMeeting(squadId, task) {
             };
         }
         finally {
+            flushTokens();
             await session.disconnect();
         }
     }));
@@ -124,6 +127,10 @@ export async function planningMeeting(squadId, task) {
         systemMessage: { content: buildFacilitatorPrompt(lead, agents, task) },
         onPermissionRequest: approveAll,
     });
+    const flushFacilitatorTokens = attachTokenTracker(facilitatorSession, {
+        squadId,
+        agentId: lead.id,
+    });
     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.`;
@@ -131,6 +138,7 @@ export async function planningMeeting(squadId, task) {
         plan = response?.data?.content ?? "Planning meeting completed but no plan was produced.";
     }
     finally {
+        flushFacilitatorTokens();
         await facilitatorSession.disconnect();
     }
     return {
@@ -143,7 +151,9 @@ export async function squadMeeting(squadId, task, executeAfter) {
     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);
+        const squad = getSquad(squadId);
+        const squadSource = squad ? `squad-${squad.slug}` : `squad-${squadId}`;
+        postFeedItem(squadSource, "Planning meeting complete — awaiting approval", summary);
         return summary;
     }
     // Execute: delegate with the plan as additional context

package/dist/copilot/io-scheduler.js

@@ -15,14 +15,22 @@ function checkIoSchedules() {
             continue;
         if (!isDue(schedule.cron, schedule.last_run, now))
             continue;
+        if (!schedule.squad_id) {
+            console.warn(`[io-scheduler] Schedule ${schedule.id} skipped: missing squad_id.`);
+            continue;
+        }
         updateScheduleLastRun(schedule.id);
-        sendToOrchestrator(schedule.prompt, "io-scheduler", (_text, done) => {
+        sendToOrchestrator(buildSquadScopedPrompt(schedule), "io-scheduler", (_text, done) => {
             if (done) {
                 console.log(`[io-scheduler] Schedule ${schedule.id} completed.`);
             }
         });
     }
 }
+export function buildSquadScopedPrompt(schedule) {
+    const squadId = schedule.squad_id ?? "unknown";
+    return `[Squad Schedule] Run for squad ${squadId}. Prompt: ${schedule.prompt}`;
+}
 function isDue(cron, lastRun, now) {
     const parts = cron.split(" ");
     if (parts.length !== 5)

package/dist/copilot/orchestrator.js

@@ -4,7 +4,9 @@ import { loadConfig } from "../config.js";
 import { buildSystemMessage } from "./system-message.js";
 import { createTools } from "./tools.js";
 import { loadSkillDirectories } from "./skills.js";
+import { getMcpServersForSession } from "../mcp/registry.js";
 import { resetClient } from "./client.js";
+import { addAuditEntry } from "../store/audit-log.js";
 let orchestratorSession;
 let sessionCreatePromise;
 let healthCheckInterval;
@@ -44,6 +46,7 @@ async function createOrResumeSession(client, opts) {
         systemMessage: { content: systemMessage },
         tools,
         skillDirectories: skillDirs,
+        mcpServers: getMcpServersForSession(),
         onPermissionRequest: approveAll,
         infiniteSessions: {
             enabled: true,
@@ -80,6 +83,7 @@ function startHealthCheck(client, opts) {
     healthCheckInterval.unref();
 }
 export async function sendToOrchestrator(prompt, source, callback) {
+    addAuditEntry("message_received", `Message from ${source}: ${prompt.slice(0, 200)}`, { source, prompt: prompt.slice(0, 1000) });
     messageQueue.push({ prompt, source, callback });
     if (!processing)
         processQueue();