heyio 0.5.0 → 0.8.0

package/dist/store/tasks.js

@@ -39,6 +39,28 @@ export function listRecentTasks(limit = 50) {
         .prepare("SELECT * FROM agent_tasks ORDER BY datetime(started_at) DESC, task_id DESC LIMIT ?")
         .all(limit);
 }
+/**
+ * Per-agent task count for the most recent `limit` tasks belonging to a
+ * squad. Matches tasks routed to the squad itself (`agent_slug = squadSlug`)
+ * AND tasks routed to a named agent on the squad (`agent_slug LIKE 'squadSlug:%'`).
+ * Used by squad_status to surface fan-out imbalance.
+ */
+export function getSquadWorkDistribution(squadSlug, limit = 20) {
+    const rows = getDb()
+        .prepare(`SELECT agent_slug FROM agent_tasks
+       WHERE agent_slug = ? OR agent_slug LIKE ?
+       ORDER BY datetime(started_at) DESC, task_id DESC
+       LIMIT ?`)
+        .all(squadSlug, `${squadSlug}:%`, limit);
+    const counts = new Map();
+    for (const row of rows) {
+        counts.set(row.agent_slug, (counts.get(row.agent_slug) ?? 0) + 1);
+    }
+    const perAgent = Array.from(counts.entries())
+        .map(([agent_slug, count]) => ({ agent_slug, count }))
+        .sort((a, b) => b.count - a.count);
+    return { total: rows.length, perAgent };
+}
 export function createReview(taskId, squadSlug, reviewerCharacter, approved, comments) {
     const db = getDb();
     const info = db
@@ -53,4 +75,104 @@ export function getTaskReviews(taskId) {
         .prepare("SELECT * FROM squad_task_reviews WHERE task_id = ? ORDER BY created_at ASC, id ASC")
         .all(taskId);
 }
+/**
+ * Per-character delegation stats for a squad.
+ *
+ * Returns one row PER CHARACTER NAME passed in `characterNames`, plus an
+ * extra row with character_name="" for any tasks routed to the bare squad
+ * slug (legacy lead tasks). Always returns a row for every requested
+ * character, even if they have never been delegated to (task_count: 0,
+ * last_delegated_at: null).
+ *
+ * Reads from the agent_stats view. Filters with `agent_slug = ?`
+ * (for the bare slug) and `agent_slug = ?` for each `<slug>:<char>`.
+ */
+export function getAgentTaskStats(squadSlug, characterNames) {
+    // Build the full set of agent_slug values we care about
+    const bareSlug = squadSlug;
+    const namedSlugs = characterNames.map((c) => `${squadSlug}:${c}`);
+    const allSlugs = [bareSlug, ...namedSlugs];
+    const placeholders = allSlugs.map(() => "?").join(", ");
+    const rows = getDb()
+        .prepare(`SELECT agent_slug, task_count, last_delegated_at FROM agent_stats WHERE agent_slug IN (${placeholders})`)
+        .all(...allSlugs);
+    const bySlug = new Map();
+    for (const row of rows)
+        bySlug.set(row.agent_slug, row);
+    const results = [];
+    // Bare slug row (legacy lead tasks routed without a named agent)
+    const bareRow = bySlug.get(bareSlug);
+    results.push({
+        character_name: "",
+        agent_slug: bareSlug,
+        task_count: bareRow?.task_count ?? 0,
+        last_delegated_at: bareRow?.last_delegated_at ?? null,
+    });
+    // One row per requested character
+    for (const char of characterNames) {
+        const slug = `${squadSlug}:${char}`;
+        const row = bySlug.get(slug);
+        results.push({
+            character_name: char,
+            agent_slug: slug,
+            task_count: row?.task_count ?? 0,
+            last_delegated_at: row?.last_delegated_at ?? null,
+        });
+    }
+    return results;
+}
+/**
+ * Pick the stalest specialist in a squad. "Stalest" = the character who
+ * has been delegated to least recently (oldest last_delegated_at), with
+ * never-delegated agents considered staler than any delegated agent.
+ *
+ * Excludes character names listed in `excludeCharacters` (use this to
+ * skip the lead). Returns null if the squad has no eligible agents OR if
+ * all eligible agents have been delegated to within `freshIfWithinHours`
+ * (default 48). The threshold is meant to suppress the hint when the
+ * squad is already distributing well.
+ *
+ * On tie (e.g. two agents have never been delegated), returns the one
+ * that sorts first by character_name (deterministic).
+ */
+export function getStalestSpecialist(squadSlug, characterNames, options) {
+    const exclude = new Set(options?.excludeCharacters ?? []);
+    const freshThresholdHours = options?.freshIfWithinHours ?? 48;
+    const stats = getAgentTaskStats(squadSlug, characterNames);
+    // Filter: named agents only (skip the bare-slug "" row), skip excluded
+    const eligible = stats.filter((s) => s.character_name !== "" && !exclude.has(s.character_name));
+    if (eligible.length === 0)
+        return null;
+    const now = Date.now();
+    // Sort: never-delegated (null) first, then ascending by last_delegated_at
+    eligible.sort((a, b) => {
+        if (a.last_delegated_at === null && b.last_delegated_at === null) {
+            return a.character_name.localeCompare(b.character_name);
+        }
+        if (a.last_delegated_at === null)
+            return -1;
+        if (b.last_delegated_at === null)
+            return 1;
+        const tA = new Date(a.last_delegated_at + "Z").getTime();
+        const tB = new Date(b.last_delegated_at + "Z").getTime();
+        if (tA !== tB)
+            return tA - tB;
+        return a.character_name.localeCompare(b.character_name);
+    });
+    const stalest = eligible[0];
+    let staleHours = null;
+    if (stalest.last_delegated_at !== null) {
+        const delegatedAt = new Date(stalest.last_delegated_at + "Z").getTime();
+        staleHours = Math.round((now - delegatedAt) / 3_600_000);
+        // Squad is distributing well — suppress the hint
+        if (staleHours < freshThresholdHours)
+            return null;
+    }
+    // null last_delegated_at means never-delegated: always considered stale
+    return {
+        character_name: stalest.character_name,
+        last_delegated_at: stalest.last_delegated_at,
+        staleHours,
+    };
+}
 //# sourceMappingURL=tasks.js.map

package/dist/telegram/bot.js

@@ -141,4 +141,18 @@ export async function sendProactiveMessage(text) {
         }
     }
 }
+/**
+ * Send a background schedule result as a Telegram notification.
+ * Delegates to sendProactiveMessage for chunking, bot-not-configured guards,
+ * and authorized-user checks — no extra logic needed here.
+ *
+ * Format (plain text, no parse_mode):
+ *   🔔 Background update — <title>
+ *
+ *   <text>
+ */
+export async function sendBackgroundNotification(opts) {
+    const formatted = `\ud83d\udd14 Background update \u2014 ${opts.title}\n\n${opts.text}`;
+    await sendProactiveMessage(formatted);
+}
 //# sourceMappingURL=bot.js.map

package/dist/tui/index.js

@@ -17,6 +17,76 @@ Type a message to chat. Commands:
   /quit                — exit
 `;
 let verbose = false;
+// Held so printBackgroundNotification can redraw the prompt around notifications.
+// Assigned inside startTui(); undefined when running headless (no TUI).
+let activeInterface;
+const NOTIFICATION_MAX_LINES = 6;
+const NOTIFICATION_WRAP_WIDTH = 78;
+/** Hard-wrap a single line to at most `width` visible chars, returning segments. */
+function wrapLine(line, width) {
+    const segments = [];
+    while (line.length > width) {
+        segments.push(line.slice(0, width));
+        line = line.slice(width);
+    }
+    segments.push(line);
+    return segments;
+}
+/**
+ * Print a background notification in a bordered block above the prompt,
+ * preserving any in-progress readline input the user has typed.
+ *
+ * Format:
+ *   ╭─🔔 Background update: <title>
+ *   │ <line1>
+ *   │ […N more lines — see /notifications]   (if truncated)
+ *   ╰─
+ *
+ * Safe to call at any time, even before startTui(). Never throws.
+ */
+export function printBackgroundNotification(opts) {
+    try {
+        // Build display lines from text, hard-wrapping long lines.
+        const rawLines = opts.text.split(/\r?\n/);
+        const displayLines = [];
+        for (const raw of rawLines) {
+            for (const seg of wrapLine(raw, NOTIFICATION_WRAP_WIDTH)) {
+                displayLines.push(seg);
+            }
+        }
+        const truncated = displayLines.length > NOTIFICATION_MAX_LINES;
+        const visible = truncated ? displayLines.slice(0, NOTIFICATION_MAX_LINES) : displayLines;
+        const extra = displayLines.length - NOTIFICATION_MAX_LINES;
+        const top = "\u256d\u2500\ud83d\udd14 Background update: " + opts.title + "\n";
+        const body = visible.map((l) => "\u2502 " + l).join("\n");
+        const overflow = truncated
+            ? "\n\u2502 [\u2026" + extra + " more line" + (extra === 1 ? "" : "s") + " \u2014 see /notifications]"
+            : "";
+        const bottom = "\n\u2570\u2500\n";
+        const block = top + body + overflow + bottom;
+        if (!activeInterface) {
+            // Headless daemon — no readline interface live; plain log is fine.
+            process.stdout.write(block);
+            return;
+        }
+        // Capture whatever the user has typed so far.
+        // readline stores the pending input in `rl.line` (stable internal property).
+        const currentLine = activeInterface.line ?? "";
+        // Clear the current prompt+input line, print the notification, then
+        // redraw the prompt with the user's buffer.
+        process.stdout.write("\r\x1b[K");
+        process.stdout.write(block);
+        if (currentLine === "") {
+            activeInterface.prompt(true);
+        }
+        else {
+            process.stdout.write("io> " + currentLine);
+        }
+    }
+    catch (err) {
+        console.error("[io] printBackgroundNotification failed:", err instanceof Error ? err.message : String(err));
+    }
+}
 function renderActivity(taskIdArg) {
     const recent = listRecentTasks(20);
     let task = undefined;
@@ -62,6 +132,9 @@ export async function startTui() {
         input: process.stdin,
         output: process.stdout,
     });
+    // Keep a module-level reference so printBackgroundNotification can redraw
+    // the prompt without disturbing the user's in-progress input.
+    activeInterface = rl;
     console.log(WELCOME_BANNER);
     rl.setPrompt("io> ");
     rl.prompt();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heyio",
-  "version": "0.5.0",
+  "version": "0.8.0",
   "description": "IO — a personal AI assistant built on the GitHub Copilot SDK",
   "bin": {
     "io": "dist/index.js"
@@ -18,7 +18,8 @@
     "daemon": "tsx src/daemon.ts",
     "tui": "tsx src/tui/index.ts",
     "dev": "tsx --watch src/daemon.ts",
-    "prepublishOnly": "npm run build:all"
+    "prepublishOnly": "npm run build:all",
+    "test": "node --import tsx --test 'src/**/*.test.ts'"
   },
   "engines": {
     "node": ">=22"