heyio 0.3.0 → 0.5.0

package/dist/api/server.js

@@ -11,6 +11,10 @@ import { abortOrchestrator } from "../copilot/orchestrator.js";
 import { getActiveTasks, getTask, listRecentTasks } from "../store/tasks.js";
 import { IO_VERSION } from "../paths.js";
 import { requireAuth } from "./auth.js";
+import { listSchedules, getSchedule, deleteSchedule, setScheduleEnabled } from "../store/schedules.js";
+import { listIoSchedules, getIoSchedule, deleteIoSchedule, setIoScheduleEnabled } from "../store/io-schedules.js";
+import { runScheduleNow } from "../copilot/scheduler.js";
+import { runIoScheduleNow } from "../copilot/io-scheduler.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const WEB_DIST = path.resolve(__dirname, "../../web-dist");
 let messageHandler;
@@ -29,7 +33,7 @@ export async function startApiServer() {
     app.use(express.json());
     app.use((_req, res, next) => {
         res.setHeader("Access-Control-Allow-Origin", "*");
-        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
         res.setHeader("Access-Control-Allow-Headers", "Content-Type");
         next();
     });
@@ -226,6 +230,172 @@ export async function startApiServer() {
             res.status(500).json({ error: "Failed to cancel task" });
         }
     });
+    // Schedules endpoints
+    api.get("/schedules", (_req, res) => {
+        try {
+            const io = listIoSchedules();
+            const squads = listSchedules();
+            res.json({ io, squads });
+        }
+        catch (e) {
+            console.error("Error listing schedules:", e);
+            res.status(500).json({ error: "Failed to list schedules" });
+        }
+    });
+    // Squad schedule lifecycle
+    api.post("/schedules/squads/:id/pause", (req, res) => {
+        const id = Number(req.params.id);
+        if (Number.isNaN(id)) {
+            res.status(400).json({ error: "Invalid schedule id" });
+            return;
+        }
+        try {
+            const ok = setScheduleEnabled(id, false);
+            if (!ok) {
+                res.status(404).json({ error: "Squad schedule not found" });
+                return;
+            }
+            res.json({ ok: true, schedule: getSchedule(id) });
+        }
+        catch (e) {
+            console.error("Error pausing squad schedule:", e);
+            res.status(500).json({ error: (e instanceof Error ? e.message : String(e)) });
+        }
+    });
+    api.post("/schedules/squads/:id/resume", (req, res) => {
+        const id = Number(req.params.id);
+        if (Number.isNaN(id)) {
+            res.status(400).json({ error: "Invalid schedule id" });
+            return;
+        }
+        try {
+            const ok = setScheduleEnabled(id, true);
+            if (!ok) {
+                res.status(404).json({ error: "Squad schedule not found" });
+                return;
+            }
+            res.json({ ok: true, schedule: getSchedule(id) });
+        }
+        catch (e) {
+            console.error("Error resuming squad schedule:", e);
+            res.status(500).json({ error: (e instanceof Error ? e.message : String(e)) });
+        }
+    });
+    api.post("/schedules/squads/:id/run-now", async (req, res) => {
+        const id = Number(req.params.id);
+        if (Number.isNaN(id)) {
+            res.status(400).json({ error: "Invalid schedule id" });
+            return;
+        }
+        try {
+            const result = await runScheduleNow(id);
+            if (!result.ok) {
+                res.status(404).json({ error: result.error ?? "Squad schedule not found" });
+                return;
+            }
+            res.json({ ok: true });
+        }
+        catch (e) {
+            console.error("Error running squad schedule now:", e);
+            res.status(500).json({ error: (e instanceof Error ? e.message : String(e)) });
+        }
+    });
+    api.delete("/schedules/squads/:id", (req, res) => {
+        const id = Number(req.params.id);
+        if (Number.isNaN(id)) {
+            res.status(400).json({ error: "Invalid schedule id" });
+            return;
+        }
+        try {
+            const ok = deleteSchedule(id);
+            if (!ok) {
+                res.status(404).json({ error: "Squad schedule not found" });
+                return;
+            }
+            res.json({ ok: true });
+        }
+        catch (e) {
+            console.error("Error deleting squad schedule:", e);
+            res.status(500).json({ error: (e instanceof Error ? e.message : String(e)) });
+        }
+    });
+    // IO schedule lifecycle
+    api.post("/schedules/io/:id/pause", (req, res) => {
+        const id = Number(req.params.id);
+        if (Number.isNaN(id)) {
+            res.status(400).json({ error: "Invalid schedule id" });
+            return;
+        }
+        try {
+            const ok = setIoScheduleEnabled(id, false);
+            if (!ok) {
+                res.status(404).json({ error: "IO schedule not found" });
+                return;
+            }
+            res.json({ ok: true, schedule: getIoSchedule(id) });
+        }
+        catch (e) {
+            console.error("Error pausing IO schedule:", e);
+            res.status(500).json({ error: (e instanceof Error ? e.message : String(e)) });
+        }
+    });
+    api.post("/schedules/io/:id/resume", (req, res) => {
+        const id = Number(req.params.id);
+        if (Number.isNaN(id)) {
+            res.status(400).json({ error: "Invalid schedule id" });
+            return;
+        }
+        try {
+            const ok = setIoScheduleEnabled(id, true);
+            if (!ok) {
+                res.status(404).json({ error: "IO schedule not found" });
+                return;
+            }
+            res.json({ ok: true, schedule: getIoSchedule(id) });
+        }
+        catch (e) {
+            console.error("Error resuming IO schedule:", e);
+            res.status(500).json({ error: (e instanceof Error ? e.message : String(e)) });
+        }
+    });
+    api.post("/schedules/io/:id/run-now", async (req, res) => {
+        const id = Number(req.params.id);
+        if (Number.isNaN(id)) {
+            res.status(400).json({ error: "Invalid schedule id" });
+            return;
+        }
+        try {
+            const ok = await runIoScheduleNow(id);
+            if (!ok) {
+                res.status(404).json({ error: "IO schedule not found" });
+                return;
+            }
+            res.json({ ok: true });
+        }
+        catch (e) {
+            console.error("Error running IO schedule now:", e);
+            res.status(500).json({ error: (e instanceof Error ? e.message : String(e)) });
+        }
+    });
+    api.delete("/schedules/io/:id", (req, res) => {
+        const id = Number(req.params.id);
+        if (Number.isNaN(id)) {
+            res.status(400).json({ error: "Invalid schedule id" });
+            return;
+        }
+        try {
+            const ok = deleteIoSchedule(id);
+            if (!ok) {
+                res.status(404).json({ error: "IO schedule not found" });
+                return;
+            }
+            res.json({ ok: true });
+        }
+        catch (e) {
+            console.error("Error deleting IO schedule:", e);
+            res.status(500).json({ error: (e instanceof Error ? e.message : String(e)) });
+        }
+    });
     // Chat endpoints
     api.post("/message", async (req, res) => {
         const { text } = req.body;

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)