heyio 0.2.1 → 0.4.0

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/orchestrator.js

@@ -89,6 +89,7 @@ function getToolDeps() {
             reviewer_character: r.reviewer_character,
             approved: r.approved,
             comments: r.comments,
+            squad_slug: r.squad_slug,
         })),
         listSkills,
         installSkill,

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

@@ -0,0 +1,171 @@
+// 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, setScheduleTimestamps, 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.
+ *
+ * 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` };
+    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

@@ -93,12 +93,37 @@ 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"]\`.
+
+### 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"