heyio 0.2.1 → 0.4.0

package/dist/copilot/tools.js

@@ -5,6 +5,45 @@ 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 { createIoSchedule, deleteIoSchedule, getIoSchedule, listIoSchedules, setIoScheduleEnabled, updateIoScheduleNextRun, } from "../store/io-schedules.js";
+import { runIoScheduleNow } from "./io-scheduler.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 +157,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 +197,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 +428,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 +1070,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 +1141,242 @@ 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). last_run_at and next_run_at are preserved so the regular schedule is untouched.",
+        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.`;
+        },
+    });
+    // -------------------------------------------------------------------------
+    // IO-level (squad-independent) schedules.
+    // -------------------------------------------------------------------------
+    const scheduleCreate = defineTool("schedule_create", {
+        description: "Schedule a recurring task for IO itself (no squad required). At the scheduled time, the prompt is delivered to the orchestrator as a background message, just like any TUI/Telegram input. Use for daily digests, health checks, monitoring, or any automation that does not belong to a project squad.",
+        skipPermission: true,
+        parameters: z.object({
+            name: z
+                .string()
+                .describe("Human-friendly name, e.g. 'Morning digest' or 'Hourly health check'"),
+            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."),
+            prompt: z
+                .string()
+                .describe("The prompt to send to the orchestrator each time the schedule fires. Treat it like the message a user would type — concrete, action-oriented."),
+            notes: z
+                .string()
+                .optional()
+                .describe("Optional operator notes appended to the prompt."),
+        }),
+        handler: async ({ name, cron, prompt, notes }) => {
+            const v = validateCron(cron);
+            if (!v.ok)
+                return `Invalid cron expression: ${v.error}`;
+            const created = createIoSchedule({
+                name,
+                cronExpr: cron,
+                prompt,
+                notes: notes ?? null,
+                nextRunAt: v.next.toISOString(),
+            });
+            return `⏰ Scheduled IO task "${created.name}" (id ${created.id}).\n- Cron: \`${cron}\`\n- Next run: ${v.next.toISOString()}`;
+        },
+    });
+    const scheduleList = defineTool("schedule_list", {
+        description: "List all IO-level schedules (those not attached to a squad). For squad schedules, use squad_schedule_list.",
+        skipPermission: true,
+        parameters: z.object({}),
+        handler: async () => {
+            const schedules = listIoSchedules();
+            if (schedules.length === 0) {
+                return "No IO 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 ?? "—";
+                const promptPreview = s.prompt.length > 120 ? s.prompt.slice(0, 120) + "…" : s.prompt;
+                return `- **${s.name}** (id ${s.id}) — ${enabled}\n    cron: \`${s.cron_expr}\`\n    next: ${next} — ${last}\n    prompt: ${promptPreview.replace(/\n/g, " ")}${s.notes ? `\n    notes: ${s.notes}` : ""}`;
+            })
+                .join("\n");
+        },
+    });
+    const scheduleDelete = defineTool("schedule_delete", {
+        description: "Delete an IO schedule by id.",
+        skipPermission: true,
+        parameters: z.object({
+            id: z.number().int().describe("Schedule id (from schedule_list)"),
+        }),
+        handler: async ({ id }) => {
+            const existing = getIoSchedule(id);
+            if (!existing)
+                return `IO schedule ${id} not found.`;
+            deleteIoSchedule(id);
+            return `🗑️ Deleted IO schedule "${existing.name}" (id ${id}).`;
+        },
+    });
+    const schedulePause = defineTool("schedule_pause", {
+        description: "Pause an IO schedule so it stops firing (preserves config — resume with schedule_resume).",
+        skipPermission: true,
+        parameters: z.object({ id: z.number().int().describe("Schedule id") }),
+        handler: async ({ id }) => {
+            const existing = getIoSchedule(id);
+            if (!existing)
+                return `IO schedule ${id} not found.`;
+            setIoScheduleEnabled(id, false);
+            return `⏸️ Paused IO schedule "${existing.name}" (id ${id}).`;
+        },
+    });
+    const scheduleResume = defineTool("schedule_resume", {
+        description: "Resume a paused IO 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 = getIoSchedule(id);
+            if (!existing)
+                return `IO schedule ${id} not found.`;
+            setIoScheduleEnabled(id, true);
+            try {
+                const next = nextRun(existing.cron_expr);
+                updateIoScheduleNextRun(id, next.toISOString());
+                return `▶️ Resumed IO schedule "${existing.name}" (id ${id}). Next run: ${next.toISOString()}`;
+            }
+            catch (err) {
+                return `Resumed IO schedule "${existing.name}" but failed to compute next run: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+    const scheduleRunNow = defineTool("schedule_run_now", {
+        description: "Manually fire an IO schedule immediately (useful for testing). last_run_at and next_run_at are preserved so the regular schedule is untouched.",
+        skipPermission: true,
+        parameters: z.object({ id: z.number().int().describe("Schedule id") }),
+        handler: async ({ id }) => {
+            const ok = await runIoScheduleNow(id);
+            if (!ok)
+                return `IO schedule ${id} not found.`;
+            return `🚀 Fired IO schedule ${id} now.`;
+        },
+    });
+    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, scheduleCreate, scheduleList, scheduleDelete, schedulePause, scheduleResume, scheduleRunNow, 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,10 @@ 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 { reconcileAgentStatuses, reconcileSquadStatuses } from "./store/squads.js";
+import { backfillReviewVerdicts } from "./copilot/review-backfill.js";
+import { startScheduler, stopScheduler } from "./copilot/scheduler.js";
+import { startIoScheduler, stopIoScheduler } from "./copilot/io-scheduler.js";
 import { config } from "./config.js";
 import { ensureWikiStructure } from "./wiki/fs.js";
 import { autoUpdate } from "./update.js";
@@ -61,8 +65,28 @@ export async function startDaemon() {
     if (wikiIsNew) {
         console.log("[io] Created wiki at ~/.io/wiki/");
     }
-    // Clear stale tasks from previous run
+    // Clear stale tasks from previous run, and reset any agent/squad rows left
+    // in 'working' or 'error' state — the in-memory Copilot sessions backing
+    // those rows did not survive the restart, so the persisted status is lying.
     clearStaleTasks();
+    const resetAgents = reconcileAgentStatuses();
+    const resetSquads = reconcileSquadStatuses();
+    if (resetAgents > 0 || resetSquads > 0) {
+        console.log(`[io] Reconciled stale statuses on startup: ${resetAgents} agent(s), ${resetSquads} squad(s) → idle`);
+    }
+    // Backfill any historical peer-review rows whose recorded verdict (approved
+    // 0/1) does not match what the current parser would extract from the prose.
+    // Earlier daemon builds had a brittle first-line-only parser that flipped
+    // many APPROVED reviews into REJECTED (issue #50).
+    try {
+        const fixed = backfillReviewVerdicts();
+        if (fixed > 0) {
+            console.log(`[io] Backfilled ${fixed} peer-review verdict(s) using current parser`);
+        }
+    }
+    catch (err) {
+        console.error("[io] Review-verdict backfill failed:", err instanceof Error ? err.message : err);
+    }
     // Prune old sessions
     pruneOldSessions();
     // Start Copilot SDK client
@@ -90,6 +114,10 @@ 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();
+    // Start the IO-level scheduler (squad-independent recurring tasks).
+    startIoScheduler();
     console.log("[io] IO is fully operational.");
     // Notify Telegram if restarting
     if (config.telegramEnabled && process.env.IO_RESTARTED === "1") {
@@ -117,6 +145,8 @@ async function shutdown() {
         }
         catch { /* best effort */ }
     }
+    stopScheduler();
+    stopIoScheduler();
     await shutdownOrchestrator();
     try {
         await stopClient();

package/dist/store/db.js

@@ -82,6 +82,33 @@ 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)`,
+        `CREATE TABLE IF NOT EXISTS io_schedules (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      cron_expr TEXT NOT NULL,
+      prompt 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_io_schedules_due
+       ON io_schedules (enabled, next_run_at)`,
     ];
     for (const migration of migrations) {
         try {

package/dist/store/io-schedules.js

@@ -0,0 +1,63 @@
+import { getDb } from "./db.js";
+export function createIoSchedule(input) {
+    const db = getDb();
+    const info = db
+        .prepare(`INSERT INTO io_schedules
+         (name, cron_expr, prompt, notes, enabled, next_run_at)
+       VALUES (?, ?, ?, ?, 1, ?)`)
+        .run(input.name, input.cronExpr, input.prompt, input.notes ?? null, input.nextRunAt);
+    const id = Number(info.lastInsertRowid);
+    return getIoSchedule(id);
+}
+export function getIoSchedule(id) {
+    return getDb()
+        .prepare("SELECT * FROM io_schedules WHERE id = ?")
+        .get(id);
+}
+export function listIoSchedules() {
+    return getDb()
+        .prepare("SELECT * FROM io_schedules ORDER BY id ASC")
+        .all();
+}
+export function listDueIoSchedules(now) {
+    return getDb()
+        .prepare(`SELECT * FROM io_schedules
+        WHERE enabled = 1
+          AND next_run_at IS NOT NULL
+          AND next_run_at <= ?
+        ORDER BY next_run_at ASC`)
+        .all(now.toISOString());
+}
+export function deleteIoSchedule(id) {
+    const info = getDb()
+        .prepare("DELETE FROM io_schedules WHERE id = ?")
+        .run(id);
+    return info.changes > 0;
+}
+export function setIoScheduleEnabled(id, enabled) {
+    const info = getDb()
+        .prepare("UPDATE io_schedules SET enabled = ? WHERE id = ?")
+        .run(enabled ? 1 : 0, id);
+    return info.changes > 0;
+}
+export function recordIoScheduleRun(id, ranAt, nextRunAt) {
+    getDb()
+        .prepare("UPDATE io_schedules SET last_run_at = ?, next_run_at = ? WHERE id = ?")
+        .run(ranAt.toISOString(), nextRunAt, id);
+}
+export function updateIoScheduleNextRun(id, nextRunAt) {
+    getDb()
+        .prepare("UPDATE io_schedules SET next_run_at = ? WHERE id = ?")
+        .run(nextRunAt, id);
+}
+/**
+ * Overwrite both last_run_at and next_run_at directly. Unlike
+ * recordIoScheduleRun this accepts NULL for last_run_at, which is needed when
+ * restoring a schedule's "never run" state after a manual run_now.
+ */
+export function setIoScheduleTimestamps(id, lastRunAt, nextRunAt) {
+    getDb()
+        .prepare("UPDATE io_schedules SET last_run_at = ?, next_run_at = ? WHERE id = ?")
+        .run(lastRunAt, nextRunAt, id);
+}
+//# sourceMappingURL=io-schedules.js.map

package/dist/store/schedules.js

@@ -0,0 +1,83 @@
+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);
+}
+/**
+ * Overwrite both last_run_at and next_run_at directly. Unlike
+ * recordScheduleRun this accepts NULL for last_run_at, which is needed when
+ * restoring a schedule's "never run" state after a manual run_now.
+ */
+export function setScheduleTimestamps(id, lastRunAt, nextRunAt) {
+    getDb()
+        .prepare("UPDATE squad_schedules SET last_run_at = ?, next_run_at = ? WHERE id = ?")
+        .run(lastRunAt, nextRunAt, id);
+}
+//# sourceMappingURL=schedules.js.map

package/dist/store/squads.js

@@ -93,6 +93,27 @@ export function updateAgentStatus(squadSlug, characterName, status) {
         .prepare("UPDATE squad_agents SET status = ? WHERE squad_slug = ? AND character_name = ?")
         .run(status, squadSlug, characterName);
 }
+/**
+ * Reset any agent left in a non-idle status from a previous daemon run.
+ * The in-memory Copilot sessions don't survive a restart, so persisted
+ * "working" or "error" rows can never be accurate after startup. Returns
+ * the number of rows reset for logging.
+ */
+export function reconcileAgentStatuses() {
+    const info = getDb()
+        .prepare("UPDATE squad_agents SET status = 'idle' WHERE status IN ('working', 'error')")
+        .run();
+    return info.changes;
+}
+/**
+ * Mirror of reconcileAgentStatuses for squads themselves.
+ */
+export function reconcileSquadStatuses() {
+    const info = getDb()
+        .prepare("UPDATE squads SET status = 'idle' WHERE status IN ('working', 'error')")
+        .run();
+    return info.changes;
+}
 export function logDecision(squadSlug, decision, context) {
     getDb()
         .prepare("INSERT INTO squad_decisions (squad_slug, decision, context) VALUES (?, ?, ?)")