heyio 0.2.1 → 0.3.0

package/dist/copilot/scheduler.js

@@ -0,0 +1,155 @@
+// Squad scheduler — fires recurring "stand-up" meetings on a cron schedule.
+//
+// Design:
+//   - Runs as a single setInterval on the daemon (TICK_MS).
+//   - Each tick: fetch schedules whose next_run_at is in the past.
+//   - For each due schedule: compose a stand-up prompt and delegate it to the
+//     squad lead via the existing delegateToAgent() pipeline. The lead then
+//     orchestrates the agenda by delegating subtasks to teammates internally.
+//   - After firing, advance next_run_at to the next cron occurrence.
+//
+// Schedules survive daemon restarts because next_run_at is persisted. On
+// startup we backfill any next_run_at fields that became stale (or are NULL).
+import { listSchedules, listDueSchedules, recordScheduleRun, updateNextRun } from "../store/schedules.js";
+import { getSquad } from "../store/squads.js";
+import { delegateToAgent } from "./agents.js";
+import { nextRun } from "./cron.js";
+const TICK_MS = 30_000;
+const AGENDA_BLOCKS = {
+    triage: `**Triage**
+- Use the GitHub CLI (\`gh issue list\`) to pull open issues with the \`needs-triage\` label.
+- For each issue: read the body and decide on appropriate labels (priority, area, type, etc).
+- Apply labels with \`gh issue edit <num> --add-label "..."\` and remove \`needs-triage\` once labelled.
+- If the issue lacks information, post a clarifying comment with \`gh issue comment\` instead of labelling, and leave \`needs-triage\` on it.`,
+    prioritize: `**Prioritize**
+- Identify open issues that are ready to be worked on: properly labelled, not blocked, no \`needs-triage\` or \`needs-review\` label, no open PR already addressing them.
+- Rank by priority labels and surface the top candidate.
+- After the stand-up, the team lead should immediately begin work on the highest-priority ready issue by delegating it to the right teammate.`,
+    ideation: `**Ideation**
+- Brainstorm 1–3 concrete improvements or new features for the project.
+- Discuss as a team (use \`delegate_to_teammate\` to gather input from members whose expertise fits the idea).
+- For each idea the team agrees on, create a GitHub issue with \`gh issue create\` tagged with the \`needs-review\` label so the human can approve it before work begins.`,
+};
+function buildStandupPrompt(squad, schedule) {
+    const blocks = schedule.agenda
+        .map((item) => AGENDA_BLOCKS[item] ?? `**${item}** _(no built-in template — improvise)_`)
+        .join("\n\n");
+    const notes = schedule.notes ? `\n\n**Operator notes:** ${schedule.notes}` : "";
+    return `# Scheduled stand-up: ${schedule.name}
+
+You are the team lead for the **${squad.name}** squad (\`${squad.slug}\`). Run a stand-up meeting now.
+
+**Project path:** \`${squad.project_path}\` — \`cd\` here before invoking the GitHub CLI so it picks up the right repo.
+
+**Agenda** (work through these in order; use \`delegate_to_teammate\` to pull in the right specialist for each item):
+
+${blocks}
+
+When you finish the agenda, summarise what was triaged, what was prioritised (and what work you've kicked off), and what new issues were filed during ideation.${notes}`;
+}
+let timer;
+const inFlight = new Set();
+async function fireSchedule(schedule) {
+    if (inFlight.has(schedule.id))
+        return;
+    const squad = getSquad(schedule.squad_slug);
+    if (!squad) {
+        console.error(`[io] scheduler: squad "${schedule.squad_slug}" missing for schedule ${schedule.id}; disabling next_run_at`);
+        updateNextRun(schedule.id, null);
+        return;
+    }
+    inFlight.add(schedule.id);
+    const ranAt = new Date();
+    let nextIso = null;
+    try {
+        nextIso = nextRun(schedule.cron_expr, ranAt).toISOString();
+    }
+    catch (err) {
+        console.error(`[io] scheduler: cron parse error for schedule ${schedule.id}:`, err instanceof Error ? err.message : err);
+    }
+    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"})`);
+    try {
+        await delegateToAgent(squad.slug, prompt, () => {
+            // No-op: result is recorded on the agent task; the standup is fire-and-forget.
+        });
+    }
+    catch (err) {
+        console.error(`[io] scheduler: failed to delegate stand-up for schedule ${schedule.id}:`, err instanceof Error ? err.message : err);
+    }
+    finally {
+        inFlight.delete(schedule.id);
+    }
+}
+async function tick() {
+    let due;
+    try {
+        due = listDueSchedules(new Date());
+    }
+    catch (err) {
+        console.error("[io] scheduler tick failed:", err instanceof Error ? err.message : err);
+        return;
+    }
+    for (const s of due) {
+        // Sequential — avoid stampeding multiple stand-ups simultaneously.
+        await fireSchedule(s);
+    }
+}
+/**
+ * Backfill next_run_at for any schedules where it's NULL or already in the past
+ * but should not have fired (e.g. daemon was offline). We deliberately advance
+ * to the next future occurrence rather than replaying missed runs.
+ */
+export function reconcileSchedules(now = new Date()) {
+    for (const s of listSchedules()) {
+        if (!s.enabled)
+            continue;
+        let needsUpdate = false;
+        if (!s.next_run_at) {
+            needsUpdate = true;
+        }
+        else {
+            const next = new Date(s.next_run_at);
+            if (Number.isNaN(next.getTime()) || next <= now)
+                needsUpdate = true;
+        }
+        if (!needsUpdate)
+            continue;
+        try {
+            const next = nextRun(s.cron_expr, now);
+            updateNextRun(s.id, next.toISOString());
+        }
+        catch (err) {
+            console.error(`[io] scheduler: invalid cron "${s.cron_expr}" on schedule ${s.id}; disabling next_run_at:`, err instanceof Error ? err.message : err);
+            updateNextRun(s.id, null);
+        }
+    }
+}
+export function startScheduler() {
+    if (timer)
+        return;
+    reconcileSchedules();
+    timer = setInterval(() => {
+        void tick();
+    }, TICK_MS);
+    if (typeof timer.unref === "function")
+        timer.unref();
+    console.log(`[io] Scheduler started (tick every ${TICK_MS / 1000}s)`);
+}
+export function stopScheduler() {
+    if (!timer)
+        return;
+    clearInterval(timer);
+    timer = undefined;
+}
+/** Manually fire a schedule. Used by squad_schedule_run_now. */
+export async function runScheduleNow(scheduleId) {
+    const all = listSchedules();
+    const s = all.find((x) => x.id === scheduleId);
+    if (!s)
+        return { ok: false, error: `Schedule ${scheduleId} not found` };
+    await fireSchedule(s);
+    return { ok: true };
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/copilot/system-message.js

@@ -93,12 +93,29 @@ Every squad should have a **team lead**. After building the team with \`squad_ad
 ### Peer Review & QA Approvals
 When an agent finishes a task, the other squad members automatically review the work and vote APPROVED or REJECTED. Reviews are recorded and emitted as \`task.review\` events.
 
-- Designate QA reviewers with \`squad_set_qa\` — typically agents focused on testing, security, or quality.
-- **QA agents have veto power**: if any QA reviewer rejects, the PR stays as a draft.
+- **Required**: every squad must have at least one agent designated as QA via \`squad_set_qa\`, AND at least one agent whose role title implies a testing/quality focus (e.g. role contains "test", "qa", or "quality"). Both can be the same agent.
+- \`squad_status\`, \`squad_agents\`, and \`squad_delegate\` will surface a ⚠️ warning when either is missing. Delegation is not blocked, but you should fix the gap before promoting work.
+- **QA agents and the team lead have veto power**: if any QA reviewer or the team lead rejects, the PR stays as a draft. The lead's veto is automatic — no need to also designate them as QA.
 - Non-QA rejections are advisory — they're recorded but don't block promotion.
 - When all QA approvals pass (or no QA agents exist) and the task result contains a GitHub PR URL, the PR is automatically promoted from draft to ready via \`gh pr ready\`.
 - Use \`squad_task_reviews\` to inspect the reviews on any completed task.
 
+### Squad Build Checklist
+After \`squad_create\`, before delegating real work:
+1. Add agents with \`squad_add_agent\` (use roles tailored to the project's stack).
+2. Include at least one **test/quality engineer** role (e.g. "Integration Test Engineer", "QA Specialist", "Quality Reviewer").
+3. Designate a team lead with \`squad_set_lead\`.
+4. Designate at least one QA reviewer with \`squad_set_qa\` (often the same agent as the test engineer).
+
+### Scheduled Stand-ups
+Squads can be put on a recurring cron-style schedule. At the scheduled time IO wakes the team lead, who runs the agenda by delegating to teammates. This runs in the background even when no human is in the TUI/Telegram.
+
+- \`squad_schedule_create\` — create a recurring stand-up. Cron uses standard 5-field syntax: "minute hour day-of-month month day-of-week". Examples: \`0 5 * * *\` (daily 5AM), \`0 9 * * 1-5\` (9AM weekdays), \`30 14 * * 1\` (Mondays 14:30).
+- Built-in agenda items: \`triage\` (process \`needs-triage\` issues), \`prioritize\` (pick highest-priority ready work and start on it), \`ideation\` (brainstorm and open \`needs-review\` issues for the human). Custom items are passed verbatim to the lead.
+- \`squad_schedule_list\`, \`squad_schedule_pause\`, \`squad_schedule_resume\`, \`squad_schedule_delete\`, \`squad_schedule_run_now\` round out the lifecycle.
+
+When a user asks something like "have the IO squad meet every weekday at 5AM to triage and prioritize", call \`squad_schedule_create\` with \`cron: "0 5 * * 1-5"\` and \`agenda: ["triage", "prioritize"]\`.
+
 ### Agent Roles Are Dynamic
 **Do NOT use generic roles** like "developer" or "tester". Analyze the project first and create roles that match its actual technology stack. Examples:
 - IO project → "Copilot SDK Specialist", "Vue.js Frontend Dev", "Express API Engineer"

package/dist/copilot/tools.js

@@ -5,6 +5,43 @@ import { readFileSync, writeFileSync, readdirSync, statSync, existsSync, mkdirSy
 import { join, dirname, resolve } from "path";
 import { homedir } from "os";
 import { UNIVERSES } from "./universes.js";
+import { validateCron, nextRun } from "./cron.js";
+import { createSchedule, deleteSchedule, getSchedule, listSchedules, setScheduleEnabled, } from "../store/schedules.js";
+import { runScheduleNow } from "./scheduler.js";
+// ---------------------------------------------------------------------------
+// QA / test coverage heuristics
+//
+// Every squad must have:
+//   1. At least one agent designated as QA (is_qa === 1) - see squad_set_qa.
+//   2. At least one agent whose role title implies a testing/quality focus.
+//
+// These are surfaced as warnings on squad_status, squad_agents, and
+// squad_delegate so users can fix coverage gaps before promoting work.
+// ---------------------------------------------------------------------------
+const TEST_ROLE_KEYWORDS = ["test", "qa", "quality", "tester", "sdet", "qe"];
+export function roleLooksLikeTesting(roleTitle) {
+    if (!roleTitle)
+        return false;
+    const lower = roleTitle.toLowerCase();
+    return TEST_ROLE_KEYWORDS.some((kw) => {
+        const re = new RegExp(`(^|[^a-z])${kw}([^a-z]|$)`);
+        return re.test(lower);
+    });
+}
+export function assessSquadCoverage(agents) {
+    const hasQa = agents.some((a) => a.is_qa === 1);
+    const hasTestRole = agents.some((a) => roleLooksLikeTesting(a.role_title));
+    const missing = [];
+    if (!hasQa)
+        missing.push("QA reviewer (use squad_set_qa)");
+    if (!hasTestRole) {
+        missing.push("test/quality engineer (add an agent whose role_title contains 'test', 'qa', or 'quality')");
+    }
+    const warning = missing.length > 0
+        ? `⚠️ Squad coverage gap: missing ${missing.join(" and ")}.`
+        : null;
+    return { hasQa, hasTestRole, missing, warning };
+}
 // Ensure child processes have HOME set (systemd services often don't)
 function shellEnv() {
     const env = { ...process.env };
@@ -118,7 +155,9 @@ export function createTools(deps) {
                 const agentList = agents.length > 0
                     ? "\n  Agents: " + agents.map((a) => `${a.character_name} (${a.role_title})`).join(", ")
                     : "\n  Agents: none — use squad_add_agent to build the team";
-                return `- **${s.name}** (\`${s.slug}\`) — ${s.status} — 🎬 ${universeName}${leadLine}${agentList}\n  📁 ${s.projectPath}`;
+                const coverage = assessSquadCoverage(agents);
+                const coverageLine = coverage.warning ? `\n  ${coverage.warning}` : "";
+                return `- **${s.name}** (\`${s.slug}\`) — ${s.status} — 🎬 ${universeName}${leadLine}${agentList}${coverageLine}\n  📁 ${s.projectPath}`;
             })
                 .join("\n");
         },
@@ -156,12 +195,17 @@ export function createTools(deps) {
         }),
         handler: async ({ slug, task, agent }) => {
             console.error(`[io] squad_delegate called: ${slug}${agent ? ` → ${agent}` : ""} — ${task.slice(0, 100)}…`);
+            const roster = deps.listSquadAgents(slug);
+            const coverage = assessSquadCoverage(roster);
             try {
                 const taskId = await deps.delegateToAgent(slug, task, (id, result) => {
                     console.error(`[io] Agent task ${id} completed for squad ${slug}`);
                 }, agent);
                 const agentLabel = agent ? `agent "${agent}" in squad "${slug}"` : `squad "${slug}"`;
-                return `Task delegated to ${agentLabel}. Task ID: ${taskId}\n\nThe agent is working on this in the background. Use squad_task_status to check progress.`;
+                const warningPrefix = coverage.warning
+                    ? `${coverage.warning} Reviews from this squad will not be vetoed by a designated QA agent until this is fixed.\n\n`
+                    : "";
+                return `${warningPrefix}Task delegated to ${agentLabel}. Task ID: ${taskId}\n\nThe agent is working on this in the background. Use squad_task_status to check progress.`;
             }
             catch (err) {
                 return `Error delegating task: ${err instanceof Error ? err.message : String(err)}`;
@@ -382,7 +426,9 @@ export function createTools(deps) {
                 const qaBadge = a.is_qa === 1 ? " 🛡️ [QA]" : "";
                 return `- **${a.character_name}**${leadBadge}${qaBadge} — ${a.role_title} (${a.model_tier}) — ${a.status}${a.personality ? `\n  _${a.personality}_` : ""}`;
             });
-            return `**${squad.name}** — 🎬 ${universeName}\n\n${lines.join("\n")}`;
+            const coverage = assessSquadCoverage(agents);
+            const coverageBlock = coverage.warning ? `\n\n${coverage.warning}` : "";
+            return `**${squad.name}** — 🎬 ${universeName}\n\n${lines.join("\n")}${coverageBlock}`;
         },
     });
     // --- Squad remove agent ---
@@ -1022,11 +1068,46 @@ export function createTools(deps) {
             if (reviews.length === 0) {
                 return `No reviews found for task ${task_id}.`;
             }
+            // Look up reviewer roles (lead/qa) so we can flag where each verdict
+            // came from. Lead and QA reviewers both have veto power.
+            const rolesBySquad = new Map();
+            const rolesFor = (squadSlug, character) => {
+                let squadMap = rolesBySquad.get(squadSlug);
+                if (!squadMap) {
+                    squadMap = new Map();
+                    for (const a of deps.listSquadAgents(squadSlug)) {
+                        squadMap.set(a.character_name, {
+                            is_lead: a.is_lead === 1,
+                            is_qa: a.is_qa === 1,
+                        });
+                    }
+                    rolesBySquad.set(squadSlug, squadMap);
+                }
+                return squadMap.get(character) ?? { is_lead: false, is_qa: false };
+            };
             return reviews
                 .map((r) => {
-                const verdict = r.approved === 1 ? "✅ APPROVED" : "❌ REJECTED";
+                const { is_lead, is_qa } = rolesFor(r.squad_slug, r.reviewer_character);
+                const approved = r.approved === 1;
+                let badge = "";
+                if (is_lead && is_qa)
+                    badge = "⭐🛡️ ";
+                else if (is_lead)
+                    badge = "⭐ ";
+                else if (is_qa)
+                    badge = "🛡️ ";
+                const verdict = approved
+                    ? `${badge}✅ APPROVED`
+                    : `${badge}❌ REJECTED`;
+                const tags = [];
+                if (is_lead)
+                    tags.push("lead");
+                if (is_qa)
+                    tags.push("QA");
+                const tagSuffix = tags.length ? ` _(${tags.join(", ")})_` : "";
+                const veto = !approved && (is_lead || is_qa) ? " — **veto**" : "";
                 const comments = r.comments ? `\n  ${r.comments.replace(/\n/g, "\n  ")}` : "";
-                return `- **${r.reviewer_character}** — ${verdict}${comments}`;
+                return `- **${r.reviewer_character}**${tagSuffix} — ${verdict}${veto}${comments}`;
             })
                 .join("\n");
         },
@@ -1058,7 +1139,131 @@ export function createTools(deps) {
             }
         },
     });
-    return [wikiRead, wikiWrite, wikiSearch, wikiDelete, wikiList, squadCreate, squadRecall, squadStatus, squadLogDecision, squadDelegate, squadTaskStatus, squadDelete, squadAnalyze, squadAddAgent, squadAgents, squadRemoveAgent, squadSetLead, squadSetQA, squadTaskReviews, skillList, skillInstall, skillRemove, skillSearch, configUpdate, checkUpdate, shell, fileOps, bash, readFile, viewTool, grepTool, strReplaceEditor, github];
+    // ---------------------------------------------------------------------------
+    // Squad schedules — recurring stand-ups via cron-style expressions.
+    // ---------------------------------------------------------------------------
+    const KNOWN_AGENDA_ITEMS = ["triage", "prioritize", "ideation"];
+    const squadScheduleCreate = defineTool("squad_schedule_create", {
+        description: "Schedule a recurring stand-up for a squad. The squad wakes on the cron schedule, the team lead runs the agenda, and teammates are pulled in via delegate_to_teammate. Built-in agenda items: triage (process needs-triage issues), prioritize (pick highest-priority ready work and start it), ideation (brainstorm + open needs-review issues). Custom agenda items are passed through to the lead verbatim.",
+        skipPermission: true,
+        parameters: z.object({
+            slug: z.string().describe("Squad slug to schedule"),
+            name: z
+                .string()
+                .describe("Human-friendly name for this schedule, e.g. 'Daily 5AM stand-up'"),
+            cron: z
+                .string()
+                .describe("Standard 5-field cron expression: 'minute hour dom month dow'. Examples: '0 5 * * *' = daily at 5:00, '0 9 * * 1-5' = 9AM weekdays, '*/15 * * * *' = every 15 minutes."),
+            agenda: z
+                .array(z.string())
+                .min(1)
+                .describe(`Ordered agenda. Built-in items: ${KNOWN_AGENDA_ITEMS.join(", ")}. You may include custom items; the team lead will improvise.`),
+            notes: z
+                .string()
+                .optional()
+                .describe("Optional operator notes appended to the stand-up prompt."),
+        }),
+        handler: async ({ slug, name, cron, agenda, notes }) => {
+            const squad = deps.getSquad(slug);
+            if (!squad)
+                return `Squad not found: ${slug}`;
+            const v = validateCron(cron);
+            if (!v.ok)
+                return `Invalid cron expression: ${v.error}`;
+            const created = createSchedule({
+                squadSlug: slug,
+                name,
+                cronExpr: cron,
+                agenda,
+                notes: notes ?? null,
+                nextRunAt: v.next.toISOString(),
+            });
+            return `📅 Scheduled "${created.name}" for squad "${squad.name}" (id ${created.id}).\n- Cron: \`${cron}\`\n- Agenda: ${agenda.join(", ")}\n- Next run: ${v.next.toISOString()}`;
+        },
+    });
+    const squadScheduleList = defineTool("squad_schedule_list", {
+        description: "List squad stand-up schedules. Pass a slug to filter to one squad, or omit to list all.",
+        skipPermission: true,
+        parameters: z.object({
+            slug: z.string().optional().describe("Optional squad slug to filter"),
+        }),
+        handler: async ({ slug }) => {
+            const schedules = listSchedules(slug);
+            if (schedules.length === 0) {
+                return slug
+                    ? `No schedules for squad "${slug}".`
+                    : "No squad schedules configured.";
+            }
+            return schedules
+                .map((s) => {
+                const enabled = s.enabled ? "▶️ enabled" : "⏸️ paused";
+                const last = s.last_run_at ? `last ${s.last_run_at}` : "never run";
+                const next = s.next_run_at ?? "—";
+                return `- **${s.name}** (id ${s.id}) — squad \`${s.squad_slug}\` — ${enabled}\n    cron: \`${s.cron_expr}\` — agenda: ${s.agenda.join(", ")}\n    next: ${next} — ${last}${s.notes ? `\n    notes: ${s.notes}` : ""}`;
+            })
+                .join("\n");
+        },
+    });
+    const squadScheduleDelete = defineTool("squad_schedule_delete", {
+        description: "Delete a squad schedule by id.",
+        skipPermission: true,
+        parameters: z.object({
+            id: z.number().int().describe("Schedule id (from squad_schedule_list)"),
+        }),
+        handler: async ({ id }) => {
+            const existing = getSchedule(id);
+            if (!existing)
+                return `Schedule ${id} not found.`;
+            deleteSchedule(id);
+            return `🗑️ Deleted schedule "${existing.name}" (id ${id}).`;
+        },
+    });
+    const squadSchedulePause = defineTool("squad_schedule_pause", {
+        description: "Pause a squad schedule so it stops firing (preserves config).",
+        skipPermission: true,
+        parameters: z.object({ id: z.number().int().describe("Schedule id") }),
+        handler: async ({ id }) => {
+            const existing = getSchedule(id);
+            if (!existing)
+                return `Schedule ${id} not found.`;
+            setScheduleEnabled(id, false);
+            return `⏸️ Paused schedule "${existing.name}" (id ${id}).`;
+        },
+    });
+    const squadScheduleResume = defineTool("squad_schedule_resume", {
+        description: "Resume a paused squad schedule. The next run is computed from now using the stored cron expression.",
+        skipPermission: true,
+        parameters: z.object({ id: z.number().int().describe("Schedule id") }),
+        handler: async ({ id }) => {
+            const existing = getSchedule(id);
+            if (!existing)
+                return `Schedule ${id} not found.`;
+            setScheduleEnabled(id, true);
+            try {
+                const next = nextRun(existing.cron_expr);
+                // Update next_run_at via the store's helper would be cleaner, but we
+                // can also just re-run reconcile on next tick. Inline update:
+                const { updateNextRun } = await import("../store/schedules.js");
+                updateNextRun(id, next.toISOString());
+                return `▶️ Resumed schedule "${existing.name}" (id ${id}). Next run: ${next.toISOString()}`;
+            }
+            catch (err) {
+                return `Resumed schedule "${existing.name}" but failed to compute next run: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+    const squadScheduleRunNow = defineTool("squad_schedule_run_now", {
+        description: "Manually fire a squad schedule immediately (useful for testing). Does not affect the next scheduled occurrence.",
+        skipPermission: true,
+        parameters: z.object({ id: z.number().int().describe("Schedule id") }),
+        handler: async ({ id }) => {
+            const result = await runScheduleNow(id);
+            if (!result.ok)
+                return `Failed: ${result.error}`;
+            return `🚀 Fired schedule ${id} now. Use squad_task_status to follow the resulting stand-up.`;
+        },
+    });
+    return [wikiRead, wikiWrite, wikiSearch, wikiDelete, wikiList, squadCreate, squadRecall, squadStatus, squadLogDecision, squadDelegate, squadTaskStatus, squadDelete, squadAnalyze, squadAddAgent, squadAgents, squadRemoveAgent, squadSetLead, squadSetQA, squadTaskReviews, squadScheduleCreate, squadScheduleList, squadScheduleDelete, squadSchedulePause, squadScheduleResume, squadScheduleRunNow, skillList, skillInstall, skillRemove, skillSearch, configUpdate, checkUpdate, shell, fileOps, bash, readFile, viewTool, grepTool, strReplaceEditor, github];
 }
 function walkDirectory(dir, maxDepth = 3, depth = 0) {
     if (depth >= maxDepth)

package/dist/daemon.js

@@ -4,6 +4,7 @@ import { startApiServer, setMessageHandler as setApiHandler } from "./api/server
 import { createBot, startBot, stopBot, sendProactiveMessage, setMessageHandler as setTelegramHandler } from "./telegram/bot.js";
 import { getDb, closeDb } from "./store/db.js";
 import { clearStaleTasks } from "./store/tasks.js";
+import { startScheduler, stopScheduler } from "./copilot/scheduler.js";
 import { config } from "./config.js";
 import { ensureWikiStructure } from "./wiki/fs.js";
 import { autoUpdate } from "./update.js";
@@ -90,6 +91,8 @@ export async function startDaemon() {
     else {
         console.log("[io] Telegram not configured — skipping bot. Set telegramBotToken in ~/.io/config.json");
     }
+    // Start the squad scheduler (background cron-style stand-ups).
+    startScheduler();
     console.log("[io] IO is fully operational.");
     // Notify Telegram if restarting
     if (config.telegramEnabled && process.env.IO_RESTARTED === "1") {
@@ -117,6 +120,7 @@ async function shutdown() {
         }
         catch { /* best effort */ }
     }
+    stopScheduler();
     await shutdownOrchestrator();
     try {
         await stopClient();

package/dist/store/db.js

@@ -82,6 +82,20 @@ export function getDb() {
       comments TEXT,
       created_at DATETIME DEFAULT CURRENT_TIMESTAMP
     )`,
+        `CREATE TABLE IF NOT EXISTS squad_schedules (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      squad_slug TEXT NOT NULL,
+      name TEXT NOT NULL,
+      cron_expr TEXT NOT NULL,
+      agenda TEXT NOT NULL,
+      notes TEXT,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      last_run_at DATETIME,
+      next_run_at DATETIME,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )`,
+        `CREATE INDEX IF NOT EXISTS idx_squad_schedules_due
+       ON squad_schedules (enabled, next_run_at)`,
     ];
     for (const migration of migrations) {
         try {

package/dist/store/schedules.js

@@ -0,0 +1,73 @@
+import { getDb } from "./db.js";
+function rowToSchedule(row) {
+    let agenda = [];
+    try {
+        agenda = JSON.parse(row.agenda);
+        if (!Array.isArray(agenda))
+            agenda = [];
+    }
+    catch {
+        agenda = [];
+    }
+    return { ...row, agenda };
+}
+export function createSchedule(input) {
+    const db = getDb();
+    const info = db
+        .prepare(`INSERT INTO squad_schedules
+         (squad_slug, name, cron_expr, agenda, notes, enabled, next_run_at)
+       VALUES (?, ?, ?, ?, ?, 1, ?)`)
+        .run(input.squadSlug, input.name, input.cronExpr, JSON.stringify(input.agenda), input.notes ?? null, input.nextRunAt);
+    const id = Number(info.lastInsertRowid);
+    return getSchedule(id);
+}
+export function getSchedule(id) {
+    const row = getDb()
+        .prepare("SELECT * FROM squad_schedules WHERE id = ?")
+        .get(id);
+    return row ? rowToSchedule(row) : undefined;
+}
+export function listSchedules(squadSlug) {
+    const rows = squadSlug
+        ? getDb()
+            .prepare("SELECT * FROM squad_schedules WHERE squad_slug = ? ORDER BY id ASC")
+            .all(squadSlug)
+        : getDb()
+            .prepare("SELECT * FROM squad_schedules ORDER BY squad_slug, id ASC")
+            .all();
+    return rows.map(rowToSchedule);
+}
+export function listDueSchedules(now) {
+    const iso = now.toISOString();
+    const rows = getDb()
+        .prepare(`SELECT * FROM squad_schedules
+        WHERE enabled = 1
+          AND next_run_at IS NOT NULL
+          AND next_run_at <= ?
+        ORDER BY next_run_at ASC`)
+        .all(iso);
+    return rows.map(rowToSchedule);
+}
+export function deleteSchedule(id) {
+    const info = getDb()
+        .prepare("DELETE FROM squad_schedules WHERE id = ?")
+        .run(id);
+    return info.changes > 0;
+}
+export function setScheduleEnabled(id, enabled) {
+    const info = getDb()
+        .prepare("UPDATE squad_schedules SET enabled = ? WHERE id = ?")
+        .run(enabled ? 1 : 0, id);
+    return info.changes > 0;
+}
+export function recordScheduleRun(id, ranAt, nextRunAt) {
+    getDb()
+        .prepare("UPDATE squad_schedules SET last_run_at = ?, next_run_at = ? WHERE id = ?")
+        .run(ranAt.toISOString(), nextRunAt, id);
+}
+export function updateNextRun(id, nextRunAt) {
+    getDb()
+        .prepare("UPDATE squad_schedules SET next_run_at = ? WHERE id = ?")
+        .run(nextRunAt, id);
+}
+//# sourceMappingURL=schedules.js.map

package/dist/tui/index.js

@@ -1,4 +1,7 @@
 import { createInterface } from "readline";
+import { listRecentTasks, getTask } from "../store/tasks.js";
+import { getTaskEvents } from "../copilot/agents.js";
+import { summarize } from "../copilot/event-summary.js";
 let messageHandler;
 export function setMessageHandler(handler) {
     messageHandler = handler;
@@ -8,9 +11,49 @@ const WELCOME_BANNER = `
 ║          IO — AI Assistant           ║
 ╚══════════════════════════════════════╝
 Type a message to chat. Commands:
-  /status  — show status
-  /quit    — exit
+  /status              — show status
+  /activity [id|N]     — show summarized activity for a task (default: most recent)
+  /verbose             — toggle verbose mode (raw event detail in /activity)
+  /quit                — exit
 `;
+let verbose = false;
+function renderActivity(taskIdArg) {
+    const recent = listRecentTasks(20);
+    let task = undefined;
+    if (!taskIdArg) {
+        task = recent[0];
+    }
+    else if (/^\d+$/.test(taskIdArg)) {
+        task = recent[parseInt(taskIdArg, 10) - 1];
+    }
+    else {
+        task = getTask(taskIdArg);
+    }
+    if (!task) {
+        console.log("[io] No task found for activity view.");
+        return;
+    }
+    const events = getTaskEvents(task.task_id);
+    if (events.length === 0) {
+        console.log(`[io] No buffered activity for task ${task.task_id} (${task.status}).`);
+        return;
+    }
+    const activity = summarize(events);
+    console.log(`[io] Activity for task ${task.task_id} (${task.agent_slug}, ${task.status}) — ${activity.length} entries${verbose ? " (verbose)" : ""}`);
+    for (const e of activity) {
+        const ts = new Date(e.ts).toISOString().slice(11, 19);
+        console.log(`  ${ts} ${e.icon} ${e.summary}`);
+        if (verbose) {
+            if (e.detail) {
+                for (const line of e.detail.split(/\r?\n/))
+                    console.log(`        ${line}`);
+            }
+            else if (e.raw && typeof e.raw === "object") {
+                console.log("        " + JSON.stringify(e.raw).slice(0, 400));
+            }
+        }
+    }
+}
 function clearLine() {
     process.stdout.write("\r\x1b[K");
 }
@@ -38,6 +81,23 @@ export async function startTui() {
             rl.prompt();
             return;
         }
+        if (trimmed === "/verbose") {
+            verbose = !verbose;
+            console.log(`[io] Verbose mode ${verbose ? "ON" : "OFF"}`);
+            rl.prompt();
+            return;
+        }
+        if (trimmed === "/activity" || trimmed.startsWith("/activity ")) {
+            const arg = trimmed.slice("/activity".length).trim() || undefined;
+            try {
+                renderActivity(arg);
+            }
+            catch (err) {
+                console.error(`[io] /activity failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            rl.prompt();
+            return;
+        }
         if (!messageHandler) {
             console.log("[io] No message handler registered.");
             rl.prompt();

package/package.json

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