heyio 0.3.0 → 0.4.0

package/dist/copilot/agents.js

@@ -240,21 +240,38 @@ async function getOrCreateAgentSession(squadSlug, agent, taskDescription) {
     const tierRank = { high: 3, medium: 2, low: 1 };
     const effectiveTier = tierRank[taskTier] >= tierRank[agentTier] ? taskTier : agentTier;
     const model = getModelForTier(effectiveTier);
-    // If we have a cached session, check if the model matches; if not, destroy and recreate
+    // If we have a cached session, check if the model matches AND the agent
+    // hasn't been left in an error state by a previous task. If either is off,
+    // destroy and recreate. Reusing a session whose underlying SDK process has
+    // been throwing is how Panthro got "stuck" in error after the issue #42
+    // delegation timeout (issue #55).
     const existing = agentSessions.get(key);
     if (existing) {
-        // Sessions don't expose their model, so track it separately
-        const cachedModel = agentSessionModels.get(key);
-        if (cachedModel === model)
-            return existing;
-        // Model changed — destroy old session for the upgraded model
-        console.error(`[io] Agent ${agent.character_name}: upgrading model ${cachedModel} → ${model} for task complexity`);
-        try {
-            await existing.destroy();
+        const fresh = getSquadAgent(squadSlug, agent.character_name);
+        const persistedStatus = fresh?.status ?? agent.status;
+        if (persistedStatus === "error") {
+            console.error(`[io] Agent ${agent.character_name}: previous session ended in error — discarding cached session and recreating`);
+            try {
+                await existing.destroy();
+            }
+            catch { /* best-effort */ }
+            agentSessions.delete(key);
+            agentSessionModels.delete(key);
+        }
+        else {
+            // Sessions don't expose their model, so track it separately
+            const cachedModel = agentSessionModels.get(key);
+            if (cachedModel === model)
+                return existing;
+            // Model changed — destroy old session for the upgraded model
+            console.error(`[io] Agent ${agent.character_name}: upgrading model ${cachedModel} → ${model} for task complexity`);
+            try {
+                await existing.destroy();
+            }
+            catch { /* best-effort */ }
+            agentSessions.delete(key);
+            agentSessionModels.delete(key);
         }
-        catch { /* best-effort */ }
-        agentSessions.delete(key);
-        agentSessionModels.delete(key);
     }
     const squad = getSquad(squadSlug);
     const client = await getClient();

package/dist/copilot/io-scheduler.js

@@ -0,0 +1,132 @@
+// IO-level scheduler — fires recurring tasks for IO itself, independent of
+// any squad. Mirrors the squad scheduler in shape (TICK_MS loop, in-flight
+// guard, reconcile on startup) but dispatches into the orchestrator via
+// sendToOrchestrator with a `background` source so IO can handle the prompt
+// the same way it handles any other user message.
+import { listIoSchedules, listDueIoSchedules, recordIoScheduleRun, setIoScheduleTimestamps, updateIoScheduleNextRun, } from "../store/io-schedules.js";
+import { sendToOrchestrator } from "./orchestrator.js";
+import { nextRun } from "./cron.js";
+const TICK_MS = 30_000;
+let timer;
+const inFlight = new Set();
+function buildPrompt(schedule) {
+    const header = `# Scheduled task: ${schedule.name}\n\n_This prompt was fired automatically by the IO scheduler. Cron expression: \`${schedule.cron_expr}\`._`;
+    const notes = schedule.notes
+        ? `\n\n**Operator notes:** ${schedule.notes}`
+        : "";
+    return `${header}\n\n${schedule.prompt}${notes}`;
+}
+async function fireSchedule(schedule) {
+    if (inFlight.has(schedule.id))
+        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] io-scheduler: cron parse error for schedule ${schedule.id}:`, err instanceof Error ? err.message : err);
+    }
+    recordIoScheduleRun(schedule.id, ranAt, nextIso);
+    console.log(`[io] io-scheduler: firing schedule "${schedule.name}" (next run: ${nextIso ?? "never"})`);
+    try {
+        await sendToOrchestrator(buildPrompt(schedule), { type: "background" }, () => {
+            // No-op: scheduled work is fire-and-forget; output is captured in
+            // the orchestrator's conversation log.
+        });
+    }
+    catch (err) {
+        console.error(`[io] io-scheduler: failed to dispatch schedule ${schedule.id}:`, err instanceof Error ? err.message : err);
+    }
+    finally {
+        inFlight.delete(schedule.id);
+    }
+}
+async function tick() {
+    let due;
+    try {
+        due = listDueIoSchedules(new Date());
+    }
+    catch (err) {
+        console.error("[io] io-scheduler tick failed:", err instanceof Error ? err.message : err);
+        return;
+    }
+    for (const s of due) {
+        await fireSchedule(s);
+    }
+}
+/**
+ * Backfill next_run_at for any IO schedules that are NULL or stale. We
+ * advance to the next future occurrence rather than replaying missed runs
+ * — same semantics as the squad scheduler.
+ */
+export function reconcileIoSchedules(now = new Date()) {
+    for (const s of listIoSchedules()) {
+        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);
+            updateIoScheduleNextRun(s.id, next.toISOString());
+        }
+        catch (err) {
+            console.error(`[io] io-scheduler: invalid cron "${s.cron_expr}" on schedule ${s.id}; clearing next_run_at:`, err instanceof Error ? err.message : err);
+            updateIoScheduleNextRun(s.id, null);
+        }
+    }
+}
+export function startIoScheduler() {
+    if (timer)
+        return;
+    reconcileIoSchedules();
+    timer = setInterval(() => {
+        void tick();
+    }, TICK_MS);
+    // Don't keep the event loop alive on shutdown
+    timer.unref?.();
+}
+export function stopIoScheduler() {
+    if (timer) {
+        clearInterval(timer);
+        timer = undefined;
+    }
+}
+/**
+ * Force a schedule to run immediately. Used by the `schedule_run_now` tool.
+ *
+ * The regular tick path (`fireSchedule`) advances `last_run_at` and
+ * `next_run_at` as a side effect, which is correct for an automatic firing
+ * but is the wrong behaviour for a manual one — a user testing a schedule at
+ * 04:30 should not have the 05:00 occurrence skipped or the schedule shifted.
+ * We therefore snapshot both timestamps before firing and restore them after,
+ * leaving the persisted schedule untouched.
+ */
+export async function runIoScheduleNow(id) {
+    const all = listIoSchedules();
+    const s = all.find((x) => x.id === id);
+    if (!s)
+        return false;
+    const previousLast = s.last_run_at;
+    const previousNext = s.next_run_at;
+    try {
+        await fireSchedule(s);
+    }
+    finally {
+        // Restore the original timestamps even if fireSchedule threw, so a
+        // failed manual run cannot silently shift the schedule either.
+        setIoScheduleTimestamps(id, previousLast, previousNext);
+    }
+    return true;
+}
+//# sourceMappingURL=io-scheduler.js.map

package/dist/copilot/review-backfill.js

@@ -0,0 +1,57 @@
+import { getDb } from "../store/db.js";
+/**
+ * Surgically correct historical peer-review rows that were stored as REJECTED
+ * (approved=0) but whose comments unambiguously begin with `APPROVED` (issue
+ * #50). Earlier daemon builds (pre-#43) inspected only the literal first line,
+ * which silently flipped many APPROVED reviews into REJECTED whenever the
+ * agent began its response with a markdown rule, blank line, header, or a
+ * short prose preamble.
+ *
+ * We only flip 0 -> 1, and only when the *current* parser sees an explicit
+ * line-leading APPROVED token in the prose. We never flip 1 -> 0: doing so
+ * would destroy data on legitimate prose-only approvals (e.g. "Excellent
+ * work — ships it") that the conservative parser would otherwise downgrade.
+ *
+ * Returns the number of rows updated.
+ */
+export function backfillReviewVerdicts() {
+    const db = getDb();
+    const rows = db
+        .prepare("SELECT id, approved, comments FROM squad_task_reviews WHERE approved = 0 AND comments IS NOT NULL AND comments != ''")
+        .all();
+    const update = db.prepare("UPDATE squad_task_reviews SET approved = 1 WHERE id = ?");
+    let fixed = 0;
+    const tx = db.transaction((batch) => {
+        for (const r of batch) {
+            if (hasExplicitApproval(r.comments ?? "")) {
+                update.run(r.id);
+                fixed++;
+            }
+        }
+    });
+    tx(rows);
+    return fixed;
+}
+/**
+ * True when the comment body unambiguously starts with an APPROVED verdict —
+ * either as the first non-empty line (after stripping markdown noise) or as
+ * the verdict the current parser extracts before any REJECTED token. Anything
+ * shorter than that is left as the daemon originally recorded it.
+ */
+function hasExplicitApproval(content) {
+    const stripped = content.replace(/[*_`#>]/g, "");
+    const lines = stripped
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter(Boolean)
+        .slice(0, 10);
+    for (const line of lines) {
+        const lead = line
+            .toUpperCase()
+            .match(/^[^A-Z]*\b(APPROVED|REJECTED)\b/);
+        if (lead)
+            return lead[1] === "APPROVED";
+    }
+    return false;
+}
+//# sourceMappingURL=review-backfill.js.map

package/dist/copilot/scheduler.js

@@ -10,7 +10,7 @@
 //
 // 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 { listSchedules, listDueSchedules, recordScheduleRun, setScheduleTimestamps, updateNextRun } from "../store/schedules.js";
 import { getSquad } from "../store/squads.js";
 import { delegateToAgent } from "./agents.js";
 import { nextRun } from "./cron.js";
@@ -143,13 +143,29 @@ export function stopScheduler() {
     clearInterval(timer);
     timer = undefined;
 }
-/** Manually fire a schedule. Used by squad_schedule_run_now. */
+/**
+ * Manually fire a schedule. Used by squad_schedule_run_now.
+ *
+ * Snapshots last_run_at and next_run_at before firing and restores them
+ * after, so a manual fire never disturbs the regular schedule (a user
+ * testing a 05:00 schedule at 04:30 should not have today's 05:00 run
+ * skipped or shifted). The fireSchedule path itself advances both fields
+ * because that's correct for an automatic firing — only manual runs need
+ * to leave the schedule untouched.
+ */
 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);
+    const previousLast = s.last_run_at;
+    const previousNext = s.next_run_at;
+    try {
+        await fireSchedule(s);
+    }
+    finally {
+        setScheduleTimestamps(scheduleId, previousLast, previousNext);
+    }
     return { ok: true };
 }
 //# sourceMappingURL=scheduler.js.map

package/dist/copilot/system-message.js

@@ -116,6 +116,14 @@ Squads can be put on a recurring cron-style schedule. At the scheduled time IO w
 
 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"]\`.
 
+### IO-level Schedules (squad-independent)
+For recurring work that doesn't belong to any project squad — daily digests, periodic health checks, monitoring loops, reminders — use the IO-level scheduler instead of inventing a placeholder squad.
+
+- \`schedule_create\` — create a recurring task. Each tick the configured prompt is delivered to the orchestrator as if a user had typed it. Cron is the same 5-field syntax as squad schedules.
+- \`schedule_list\`, \`schedule_pause\`, \`schedule_resume\`, \`schedule_delete\`, \`schedule_run_now\` mirror the squad-schedule lifecycle.
+
+When a user asks "remind me at 9AM every day to check the dashboard" or "every hour, summarize my open PRs", reach for \`schedule_create\` — not a squad.
+
 ### 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

@@ -6,6 +6,8 @@ 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";
 // ---------------------------------------------------------------------------
@@ -1253,7 +1255,7 @@ export function createTools(deps) {
         },
     });
     const squadScheduleRunNow = defineTool("squad_schedule_run_now", {
-        description: "Manually fire a squad schedule immediately (useful for testing). Does not affect the next scheduled occurrence.",
+        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 }) => {
@@ -1263,7 +1265,118 @@ export function createTools(deps) {
             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];
+    // -------------------------------------------------------------------------
+    // 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,7 +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";
@@ -62,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
@@ -93,6 +116,8 @@ export async function startDaemon() {
     }
     // 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") {
@@ -121,6 +146,7 @@ async function shutdown() {
         catch { /* best effort */ }
     }
     stopScheduler();
+    stopIoScheduler();
     await shutdownOrchestrator();
     try {
         await stopClient();

package/dist/store/db.js

@@ -96,6 +96,19 @@ export function getDb() {
     )`,
         `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

@@ -70,4 +70,14 @@ export function updateNextRun(id, nextRunAt) {
         .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 (?, ?, ?)")

package/package.json

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