heyio 0.5.0 → 0.8.0

package/dist/api/server.js

@@ -3,7 +3,7 @@ import { fileURLToPath } from "node:url";
 import { existsSync } from "node:fs";
 import express from "express";
 import { config } from "../config.js";
-import { listSkills } from "../copilot/skills.js";
+import { listSkills, installSkill } 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";
@@ -15,6 +15,7 @@ import { listSchedules, getSchedule, deleteSchedule, setScheduleEnabled } from "
 import { listIoSchedules, getIoSchedule, deleteIoSchedule, setIoScheduleEnabled } from "../store/io-schedules.js";
 import { runScheduleNow } from "../copilot/scheduler.js";
 import { runIoScheduleNow } from "../copilot/io-scheduler.js";
+import { listRecentNotifications, listUnreadNotifications, countUnreadNotifications, markNotificationRead, markAllNotificationsRead, } from "../store/notifications.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const WEB_DIST = path.resolve(__dirname, "../../web-dist");
 let messageHandler;
@@ -28,6 +29,12 @@ export function broadcastToSSE(text) {
         res.write(`data: ${payload}\n\n`);
     }
 }
+export function broadcastNotificationToSSE(payload) {
+    const data = JSON.stringify({ type: "notification", ...payload });
+    for (const res of sseConnections) {
+        res.write(`data: ${data}\n\n`);
+    }
+}
 export async function startApiServer() {
     const app = express();
     app.use(express.json());
@@ -67,6 +74,36 @@ export async function startApiServer() {
             res.status(500).json({ error: "Failed to list skills" });
         }
     });
+    // Install a skill from a git repo URL (mirrors the skill_install tool)
+    api.post("/skills", async (req, res) => {
+        const { repoUrl } = req.body;
+        if (repoUrl === undefined || repoUrl === null || typeof repoUrl !== "string") {
+            res.status(400).json({ error: "Missing required field: repoUrl" });
+            return;
+        }
+        if (repoUrl.trim() === "") {
+            res.status(400).json({ error: "repoUrl must not be empty" });
+            return;
+        }
+        const trimmed = repoUrl.trim();
+        const looksLikeGitUrl = trimmed.startsWith("http://") ||
+            trimmed.startsWith("https://") ||
+            trimmed.startsWith("git@") ||
+            trimmed.startsWith("git://") ||
+            trimmed.endsWith(".git");
+        if (!looksLikeGitUrl) {
+            res.status(400).json({ error: "repoUrl does not look like a git repository URL" });
+            return;
+        }
+        try {
+            const skill = await installSkill(trimmed);
+            res.status(201).json({ skill });
+        }
+        catch (e) {
+            console.error("Error installing skill:", e);
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
     // Squads endpoints
     api.get("/squads", (_req, res) => {
         try {
@@ -162,7 +199,26 @@ export async function startApiServer() {
         const taskId = Array.isArray(req.params.taskId) ? req.params.taskId[0] : req.params.taskId;
         try {
             const events = getTaskEvents(taskId);
-            const activity = summarize(events);
+            let activity = summarize(events);
+            // Fallback: when in-memory events are gone (e.g. daemon restart),
+            // build a minimal entry from the persisted task result so the UI
+            // doesn't show "no activity" for tasks that actually ran. (#66)
+            if (activity.length === 0) {
+                const task = getTask(taskId);
+                if (task?.result) {
+                    activity = [{
+                            ts: task.completed_at ? new Date(task.completed_at).getTime() : Date.now(),
+                            kind: "outcome",
+                            icon: task.status === "failed" ? "\u274c" : task.status === "done" ? "\u2705" : "\ud83d\udccb",
+                            summary: task.status === "failed"
+                                ? "Task failed (activity log unavailable after restart)"
+                                : "Task completed (activity log unavailable after restart)",
+                            rawType: "task.result.fallback",
+                            detail: task.result,
+                            raw: { result: task.result, status: task.status },
+                        }];
+                }
+            }
             res.json({ taskId, activity });
         }
         catch (e) {
@@ -396,6 +452,69 @@ export async function startApiServer() {
             res.status(500).json({ error: (e instanceof Error ? e.message : String(e)) });
         }
     });
+    // Notifications endpoints
+    api.get("/notifications", (_req, res) => {
+        try {
+            const unreadOnly = _req.query.unread === "true";
+            const rows = unreadOnly
+                ? listUnreadNotifications()
+                : (() => {
+                    const rawLimit = _req.query.limit;
+                    const parsed = typeof rawLimit === "string" ? Number.parseInt(rawLimit, 10) : NaN;
+                    const limit = Number.isFinite(parsed) && parsed > 0 ? Math.min(parsed, 200) : 50;
+                    return listRecentNotifications(limit);
+                })();
+            const unreadCount = countUnreadNotifications();
+            const notifications = rows.map(({ id, title, text, created_at, read_at, source_type, source_ref }) => {
+                let source = { type: source_type };
+                if (source_ref) {
+                    try {
+                        const parsed = JSON.parse(source_ref);
+                        source = { type: source_type, ...parsed };
+                    }
+                    catch {
+                        // source_ref is not valid JSON — fall back to type-only
+                    }
+                }
+                return { id, title, text, created_at, read_at, source };
+            });
+            res.json({ notifications, unreadCount });
+        }
+        catch (e) {
+            console.error("Error listing notifications:", e);
+            res.status(500).json({ error: "Failed to list notifications" });
+        }
+    });
+    api.post("/notifications/read-all", (_req, res) => {
+        try {
+            const marked = markAllNotificationsRead();
+            res.json({ marked });
+        }
+        catch (e) {
+            console.error("Error marking all notifications read:", e);
+            res.status(500).json({ error: "Failed to mark notifications read" });
+        }
+    });
+    api.post("/notifications/:id/read", (req, res) => {
+        try {
+            const rawId = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+            const id = Number.parseInt(rawId, 10);
+            if (Number.isNaN(id)) {
+                res.status(400).json({ error: "invalid id" });
+                return;
+            }
+            const found = markNotificationRead(id);
+            if (!found) {
+                res.status(404).json({ error: "notification not found" });
+                return;
+            }
+            res.json({ ok: true });
+        }
+        catch (e) {
+            console.error("Error marking notification read:", e);
+            res.status(500).json({ error: "Failed to mark notification read" });
+        }
+    });
     // Chat endpoints
     api.post("/message", async (req, res) => {
         const { text } = req.body;

package/dist/config.js

@@ -4,6 +4,9 @@ const DEFAULT_CONFIG = {
     telegramEnabled: false,
     selfEditEnabled: false,
     port: 3170,
+    backgroundNotifyMode: "meaningful",
+    backgroundNotifyTelegram: true,
+    backgroundNotifyTui: true,
 };
 function loadConfig() {
     mkdirSync(IO_HOME, { recursive: true });

package/dist/copilot/agents.js

@@ -7,8 +7,9 @@ import { homedir } from "os";
 import { defineTool, approveAll } from "@github/copilot-sdk";
 import { z } from "zod";
 import { getClient } from "./client.js";
+import { sendWithIdleTimeout } from "./session-timeout.js";
 import { getModelForTask, getModelForTier, classifyComplexity } from "./model-router.js";
-import { getSquad, updateSquadSession, updateSquadStatus, getDecisionsSummary, logDecision, listSquadAgents, getSquadAgent, getSquadLead, updateAgentSession, updateAgentStatus, } from "../store/squads.js";
+import { getSquad, updateSquadSession, updateSquadStatus, getDecisions, 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";
@@ -18,6 +19,16 @@ const agentSessionModels = new Map();
 function agentSessionKey(squadSlug, characterName) {
     return characterName ? `${squadSlug}:${characterName}` : squadSlug;
 }
+/**
+ * Drop the in-memory cached Copilot session (and model) for an agent so the
+ * next task creates a fresh one. Pairs with `clearAgentSession` in the
+ * store, which nulls the persisted copilot_session_id.
+ */
+export function clearAgentInMemorySession(squadSlug, characterName) {
+    const key = agentSessionKey(squadSlug, characterName);
+    agentSessions.delete(key);
+    agentSessionModels.delete(key);
+}
 export function getAgentInfo() {
     const activeTasks = getActiveTasks();
     const tasksByAgent = new Map();
@@ -104,6 +115,49 @@ export function subscribeToTaskEvents(taskId, listener) {
     taskEventEmitter.on(taskId, listener);
     return () => taskEventEmitter.off(taskId, listener);
 }
+// ---------------------------------------------------------------------------
+// Task prompt envelope (issue #54)
+//
+// Before sending a task to an agent we prepend a short "Recent squad
+// decisions" preamble and append a tail that asks the agent to call
+// squad_log_decision if their work involved a non-trivial architectural
+// choice. This is the lowest-friction nudge we can give: agents see what
+// they're augmenting AND a reminder to capture institutional knowledge.
+// ---------------------------------------------------------------------------
+const RECENT_DECISIONS_LIMIT = 5;
+function buildTaskPromptEnvelope(squadSlug, task) {
+    const recent = getDecisions(squadSlug, RECENT_DECISIONS_LIMIT);
+    const preamble = recent.length === 0
+        ? `## Recent squad decisions
+_(None recorded yet — be the first to log one with \`squad_log_decision\` if your work involves a real architectural choice.)_`
+        : `## Recent squad decisions (last ${recent.length})
+You should treat these as load-bearing context. Reverse them only with a clear reason and a new \`squad_log_decision\` entry.
+
+${recent
+            .slice()
+            .reverse()
+            .map((d) => {
+            const ctx = d.context ? ` — _${d.context}_` : "";
+            return `- [${d.created_at}] **${d.decision}**${ctx}`;
+        })
+            .join("\n")}`;
+    const tail = `## Capturing institutional knowledge
+When you finish this task, if your work involved a non-trivial architectural choice (a strategy, a tradeoff, an interface decision, a workaround with a clear reason), call \`squad_log_decision\` with **one sentence** summarizing the choice and **a short context** explaining why. Examples:
+- decision: "Use idle-reset timeout instead of wall-clock for agent tasks" / context: "Wall-clock killed 2/3 long-running tasks mid-progress (#42, #45)."
+- decision: "Veto power expanded to lead + QA + test engineers" / context: "Single-reviewer veto was too narrow when test engineer wasn't designated QA."
+
+If your work was a routine implementation that didn't make a real choice (e.g. small docs edit, mechanical refactor, one-line fix), skip the call — don't log noise.`;
+    return `${preamble}
+
+---
+
+## Task
+${task}
+
+---
+
+${tail}`;
+}
 export async function delegateToAgent(squadSlug, task, onComplete, targetAgent) {
     const squad = getSquad(squadSlug);
     if (!squad) {
@@ -131,13 +185,26 @@ export async function delegateToAgent(squadSlug, task, onComplete, targetAgent)
             }
         }
     }
+    const agentKey = agent
+        ? agentSessionKey(squadSlug, agent.character_name)
+        : squadSlug;
+    // Idempotency: if an identical task is already running on this agent_slug,
+    // join the existing task instead of racing a second instance. (Issue #53)
+    const normalizedTask = task.trim();
+    const duplicate = getActiveTasks().find((t) => t.agent_slug === agentKey && t.description.trim() === normalizedTask);
+    if (duplicate) {
+        console.error(`[io] Dedup: task with identical description already running on ${agentKey} (taskId=${duplicate.task_id}); returning existing taskId.`);
+        recordTaskEvent(duplicate.task_id, {
+            ts: Date.now(),
+            type: "task.dedup_joined",
+            data: { agentKey, description: normalizedTask },
+        });
+        return duplicate.task_id;
+    }
     const session = agent
         ? await getOrCreateAgentSession(squadSlug, agent, task)
         : await getOrCreateSession(squadSlug, task);
     const taskId = randomUUID();
-    const agentKey = agent
-        ? agentSessionKey(squadSlug, agent.character_name)
-        : squadSlug;
     createTask(taskId, agentKey, task);
     updateSquadStatus(squadSlug, "working");
     if (agent)
@@ -161,8 +228,40 @@ export async function delegateToAgent(squadSlug, task, onComplete, targetAgent)
     // Run the task in the background — return taskId immediately
     void (async () => {
         try {
-            const response = await session.sendAndWait({ prompt: task }, 600_000);
-            const result = response?.data?.content ?? "Task completed (no output)";
+            const envelopedTask = buildTaskPromptEnvelope(squadSlug, task);
+            const sendResult = await sendWithIdleTimeout(session, envelopedTask, {
+                // Reset on every progress event; only abort if the agent goes
+                // genuinely silent for this long. 10 minutes covers the longest
+                // realistic tool call (npm install, full build, large file edits)
+                // while still catching truly stuck sessions. (Issue #53)
+                idleMs: 10 * 60_000,
+                // Absolute upper bound — 60 minutes. Anything longer is almost
+                // certainly a runaway loop; cap it.
+                hardCapMs: 60 * 60_000,
+                onIdleTimeout: ({ lastEventType, idleMs }) => {
+                    console.error(`[io] Agent task ${taskId} idle for ${Math.round(idleMs / 1000)}s (last event: ${lastEventType ?? "none"}) — aborting session.`);
+                },
+            });
+            if (sendResult.timedOut) {
+                const partial = sendResult.content;
+                recordTaskEvent(taskId, {
+                    ts: Date.now(),
+                    type: "task.timeout",
+                    data: {
+                        reason: sendResult.timeoutReason,
+                        lastEventType: sendResult.lastEventType,
+                        partial,
+                    },
+                });
+                const stamped = `[task timed out — ${sendResult.timeoutReason === "idle" ? "idle reset" : "hard cap"}; last event: ${sendResult.lastEventType ?? "none"}]\n\n${partial}`;
+                failTask(taskId, stamped);
+                updateSquadStatus(squadSlug, "idle");
+                if (agent)
+                    updateAgentStatus(squadSlug, agent.character_name, "idle");
+                onComplete(taskId, stamped);
+                return;
+            }
+            const result = sendResult.content || "Task completed (no output)";
             completeTask(taskId, result);
             updateSquadStatus(squadSlug, "idle");
             if (agent)
@@ -300,10 +399,26 @@ async function getOrCreateAgentSession(squadSlug, agent, taskDescription) {
         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
+You are the team lead for this squad. **Your sole job is coordination — you do NOT write code, own any domain, or implement features yourself.** Every incoming task must be analyzed, decomposed, and assigned to the appropriate domain specialist via the \`delegate_to_teammate\` tool. The only work you perform directly is breaking tasks down, delegating, and synthesizing results.
+
+### Fan-out planning (REQUIRED before any work begins)
+When a task arrives, BEFORE touching code or shell, you MUST:
+
+1. **List every distinct work-area** the task touches (e.g. "API endpoint", "DB migration", "frontend component", "tests", "docs"). One bullet per area.
+2. **Score each teammate's charter** against each area — for every area, name the teammate whose charter most closely matches and quote the keyword/phrase from their charter that justifies the assignment.
+3. **Produce a fan-out plan** as a short markdown list: \`- <area> → <teammate> — <one-sentence subtask>\`.
+4. **Delegate each subtask in the plan via \`delegate_to_teammate\`** — in parallel where the subtasks are independent. Do NOT shell, edit, or write code yourself between steps 1–3 and the first \`delegate_to_teammate\` call.
+
+### When you may implement directly
+Only if **all** of the following are true:
+- The task is genuinely trivial (a one-line change, a typo fix, a single-file rename) AND fits no teammate's charter better than yours.
+- No teammate's charter covers the work-area at all.
+- A prior \`delegate_to_teammate\` attempt for this exact subtask failed twice with a clear, unrecoverable error.
+
+If you find yourself reaching for the shell or file_ops on a normal feature/bug task, **stop** — that's a signal you skipped the fan-out plan. Go back and delegate.
+
+### Reviewing teammate output
+After every \`delegate_to_teammate\` call returns, read the result, decide whether it satisfies the subtask, and either accept it (move on to the next subtask) or send a follow-up \`delegate_to_teammate\` to the same teammate with the specific gap to address. Synthesize the final summary only after every subtask is accepted.
 
 ## Your Team
 ${roster}`;
@@ -324,6 +439,17 @@ ${agent.charter ?? "General-purpose agent. Handle tasks as they come."}
 ## Past Decisions
 ${decisions}${leadSection}
 
+## Repository Hygiene
+Before you make ANY code changes, you MUST sync your working copy with the remote default branch and work from a fresh feature branch. This prevents the merge conflicts the team hit on PRs like #45.
+
+1. \`cd\` to the project path above.
+2. \`git fetch origin\` — pick up everything that has merged since your last task.
+3. \`git checkout main && git pull origin main\` — fast-forward your local main.
+4. \`git checkout -b <your-handle>/<short-slug>\` — create a fresh branch from the updated main. Never commit directly to main, and never reuse a stale branch from a prior task.
+5. Only THEN start editing files, running tools, or delegating subtasks.
+
+If the project's default branch is not \`main\` (e.g. \`master\`, \`develop\`), substitute it everywhere above. If you are not in a git repository, skip this section and proceed normally.
+
 ## Instructions
 You are a coding agent. Use the shell tool to run commands and file_ops to read/write files.
 Log important decisions with squad_log_decision so they persist.
@@ -380,6 +506,17 @@ async function getOrCreateSession(squadSlug, taskDescription) {
 ## Past Decisions
 ${decisions}
 
+## Repository Hygiene
+Before you make ANY code changes, you MUST sync your working copy with the remote default branch and work from a fresh feature branch. This prevents the merge conflicts the team hit on PRs like #45.
+
+1. \`cd\` to the project path above.
+2. \`git fetch origin\` — pick up everything that has merged since your last task.
+3. \`git checkout main && git pull origin main\` — fast-forward your local main.
+4. \`git checkout -b <your-handle>/<short-slug>\` — create a fresh branch from the updated main. Never commit directly to main, and never reuse a stale branch from a prior task.
+5. Only THEN start editing files, running tools, or delegating subtasks.
+
+If the project's default branch is not \`main\` (e.g. \`master\`, \`develop\`), substitute it everywhere above. If you are not in a git repository, skip this section and proceed normally.
+
 ## Your Role
 You are a coding agent. Use the shell tool to run commands and file_ops to read/write files.
 Log important decisions with squad_log_decision so they persist.`,
@@ -549,17 +686,40 @@ function buildAgentTools(squadSlug, isLead = false) {
                     if (teammateAgent.is_lead === 1) {
                         return `Error: "${teammate}" is the team lead. Delegate to a non-lead teammate.`;
                     }
+                    // Record this sub-delegation as a first-class task so the squad's
+                    // work-distribution stats reflect real fan-out (issue #51).
+                    const childTaskId = randomUUID();
+                    const childAgentKey = agentSessionKey(squadSlug, teammateAgent.character_name);
+                    createTask(childTaskId, childAgentKey, task, "delegate_to_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)";
+                        const envelopedTask = buildTaskPromptEnvelope(squadSlug, task);
+                        // Idle-reset timeout: 10min between progress events, 30min
+                        // hard cap. (Issue #53 — replaces #51's 30min wall-clock cap
+                        // that still killed agents mid-tool-call when they had
+                        // long-running shell work between assistant messages.)
+                        const sendResult = await sendWithIdleTimeout(session, envelopedTask, {
+                            idleMs: 10 * 60_000,
+                            hardCapMs: 30 * 60_000,
+                            onIdleTimeout: ({ lastEventType }) => {
+                                console.error(`[io] Teammate ${teammateAgent.character_name} idle (last event: ${lastEventType ?? "none"}) — aborting.`);
+                            },
+                        });
+                        const result = sendResult.content || "(teammate returned no output)";
                         updateAgentStatus(squadSlug, teammateAgent.character_name, "idle");
+                        if (sendResult.timedOut) {
+                            const stamped = `[teammate timed out — ${sendResult.timeoutReason === "idle" ? "idle reset" : "hard cap"}; last event: ${sendResult.lastEventType ?? "none"}]\n\n${result}`;
+                            failTask(childTaskId, stamped);
+                            return stamped;
+                        }
+                        completeTask(childTaskId, result);
                         return result;
                     }
                     catch (err) {
                         updateAgentStatus(squadSlug, teammateAgent.character_name, "error");
                         const message = err instanceof Error ? err.message : String(err);
+                        failTask(childTaskId, message);
                         return `Error from teammate "${teammate}": ${message}`;
                     }
                 }

package/dist/copilot/io-scheduler.js

@@ -6,6 +6,8 @@
 import { listIoSchedules, listDueIoSchedules, recordIoScheduleRun, setIoScheduleTimestamps, updateIoScheduleNextRun, } from "../store/io-schedules.js";
 import { sendToOrchestrator } from "./orchestrator.js";
 import { nextRun } from "./cron.js";
+import { notifyBackground } from "../notify.js";
+import { startScheduleRun, completeScheduleRun, failScheduleRun } from "../store/schedule-runs.js";
 const TICK_MS = 30_000;
 let timer;
 const inFlight = new Set();
@@ -30,13 +32,34 @@ async function fireSchedule(schedule) {
     }
     recordIoScheduleRun(schedule.id, ranAt, nextIso);
     console.log(`[io] io-scheduler: firing schedule "${schedule.name}" (next run: ${nextIso ?? "never"})`);
+    const run = startScheduleRun({
+        schedule_type: "io",
+        schedule_id: schedule.id,
+        schedule_name: schedule.name,
+    });
     try {
-        await sendToOrchestrator(buildPrompt(schedule), { type: "background" }, () => {
-            // No-op: scheduled work is fire-and-forget; output is captured in
-            // the orchestrator's conversation log.
+        let buffer = "";
+        await sendToOrchestrator(buildPrompt(schedule), { type: "background" }, (text, done) => {
+            buffer += text;
+            if (done) {
+                void notifyBackground({
+                    source: {
+                        type: "io-schedule",
+                        scheduleId: schedule.id,
+                        scheduleName: schedule.name,
+                    },
+                    title: `IO schedule: ${schedule.name}`,
+                    text: buffer.trim(),
+                }).then((notifyResult) => {
+                    completeScheduleRun(run.id, notifyResult.id);
+                }).catch((err) => {
+                    failScheduleRun(run.id, err instanceof Error ? err.message : String(err));
+                });
+            }
         });
     }
     catch (err) {
+        failScheduleRun(run.id, err instanceof Error ? err.message : String(err));
         console.error(`[io] io-scheduler: failed to dispatch schedule ${schedule.id}:`, err instanceof Error ? err.message : err);
     }
     finally {

package/dist/copilot/orchestrator.js

@@ -3,8 +3,8 @@ import { approveAll, } from "@github/copilot-sdk";
 import { config } from "../config.js";
 import { SESSIONS_DIR, IO_VERSION } from "../paths.js";
 import { getState, setState, deleteState, logConversation } from "../store/db.js";
-import { clearStaleTasks, getTask, getTaskReviews } from "../store/tasks.js";
-import { getSquad, listSquads, createSquad, deleteSquad, logDecision, getDecisionsSummary, updateSquadStatus, addSquadAgent, listSquadAgents, removeSquadAgent, setSquadLead, getSquadLead, setSquadQA, } from "../store/squads.js";
+import { clearStaleTasks, getAgentTaskStats, getSquadWorkDistribution, getStalestSpecialist, getTask, getTaskReviews } from "../store/tasks.js";
+import { getSquad, listSquads, createSquad, deleteSquad, logDecision, getDecisions, getDecisionsSummary, updateSquadStatus, addSquadAgent, listSquadAgents, removeSquadAgent, updateAgentStatus, clearAgentSession, setSquadLead, getSquadLead, setSquadQA, } from "../store/squads.js";
 import { readPage, writePage, assertPagePath, deletePage, listPages } from "../wiki/fs.js";
 import { resolveModelTiers } from "./model-router.js";
 import { searchWiki, getWikiSummary } from "../wiki/search.js";
@@ -12,7 +12,7 @@ import { getOrchestratorSystemMessage } from "./system-message.js";
 import { createTools } from "./tools.js";
 import { getSkillDirectories, listSkills, installSkill, removeSkill, searchSkillsRegistry } from "./skills.js";
 import { resetClient } from "./client.js";
-import { delegateToAgent, getActiveAgentTasks } from "./agents.js";
+import { delegateToAgent, getActiveAgentTasks, clearAgentInMemorySession } from "./agents.js";
 import { saveConfig } from "../config.js";
 import { checkForUpdate } from "../update.js";
 // ---------------------------------------------------------------------------
@@ -56,6 +56,11 @@ function getToolDeps() {
         deleteSquad,
         logDecision,
         getDecisionsSummary,
+        getRecentDecisions: (slug, limit) => getDecisions(slug, limit ?? 5).map((d) => ({
+            decision: d.decision,
+            context: d.context,
+            created_at: d.created_at,
+        })),
         updateSquadStatus,
         delegateToAgent,
         getTask,
@@ -77,6 +82,25 @@ function getToolDeps() {
             is_qa: a.is_qa,
         })),
         removeSquadAgent,
+        resetSquadAgent: (squadSlug, characterName) => {
+            const agents = listSquadAgents(squadSlug);
+            const target = agents.find((a) => a.character_name === characterName);
+            if (!target) {
+                return { found: false, previousStatus: "", agent: null };
+            }
+            const previousStatus = target.status;
+            updateAgentStatus(squadSlug, characterName, "idle");
+            clearAgentSession(squadSlug, characterName);
+            clearAgentInMemorySession(squadSlug, characterName);
+            return {
+                found: true,
+                previousStatus,
+                agent: {
+                    character_name: target.character_name,
+                    role_title: target.role_title,
+                },
+            };
+        },
         setSquadLead,
         getSquadLead: (slug) => {
             const lead = getSquadLead(slug);
@@ -91,6 +115,9 @@ function getToolDeps() {
             comments: r.comments,
             squad_slug: r.squad_slug,
         })),
+        getSquadWorkDistribution: (slug, limit) => getSquadWorkDistribution(slug, limit),
+        getAgentTaskStats: (squadSlug, characterNames) => getAgentTaskStats(squadSlug, characterNames),
+        getStalestSpecialist: (squadSlug, characterNames, options) => getStalestSpecialist(squadSlug, characterNames, options),
         listSkills,
         installSkill,
         removeSkill,

package/dist/copilot/scheduler.js

@@ -14,6 +14,8 @@ import { listSchedules, listDueSchedules, recordScheduleRun, setScheduleTimestam
 import { getSquad } from "../store/squads.js";
 import { delegateToAgent } from "./agents.js";
 import { nextRun } from "./cron.js";
+import { notifyBackground } from "../notify.js";
+import { startScheduleRun, completeScheduleRun, failScheduleRun } from "../store/schedule-runs.js";
 const TICK_MS = 30_000;
 const AGENDA_BLOCKS = {
     triage: `**Triage**
@@ -70,12 +72,32 @@ async function fireSchedule(schedule) {
     recordScheduleRun(schedule.id, ranAt, nextIso);
     const prompt = buildStandupPrompt({ name: squad.name, slug: squad.slug, project_path: squad.project_path }, schedule);
     console.log(`[io] scheduler: firing schedule "${schedule.name}" for squad "${squad.slug}" (next run: ${nextIso ?? "never"})`);
+    const run = startScheduleRun({
+        schedule_type: "squad",
+        schedule_id: schedule.id,
+        schedule_name: schedule.name,
+        squad_slug: squad.slug,
+    });
     try {
-        await delegateToAgent(squad.slug, prompt, () => {
-            // No-op: result is recorded on the agent task; the standup is fire-and-forget.
+        await delegateToAgent(squad.slug, prompt, (_taskId, result) => {
+            void notifyBackground({
+                source: {
+                    type: "squad-schedule",
+                    scheduleId: schedule.id,
+                    squadSlug: squad.slug,
+                    scheduleName: schedule.name,
+                },
+                title: `${squad.name}: ${schedule.name}`,
+                text: result,
+            }).then((notifyResult) => {
+                completeScheduleRun(run.id, notifyResult.id);
+            }).catch((err) => {
+                failScheduleRun(run.id, err instanceof Error ? err.message : String(err));
+            });
         });
     }
     catch (err) {
+        failScheduleRun(run.id, err instanceof Error ? err.message : String(err));
         console.error(`[io] scheduler: failed to delegate stand-up for schedule ${schedule.id}:`, err instanceof Error ? err.message : err);
     }
     finally {