heyio 0.1.0

package/dist/copilot/tools.js

@@ -0,0 +1,239 @@
+import { defineTool } from "@github/copilot-sdk";
+import { z } from "zod";
+import { execSync } from "child_process";
+import { readFileSync, writeFileSync, readdirSync, statSync, existsSync, mkdirSync } from "fs";
+import { join, dirname, resolve } from "path";
+export function createTools(deps) {
+    const wikiRead = defineTool("wiki_read", {
+        description: "Read a page from IO's knowledge base wiki. Path is relative to the wiki root (e.g., 'pages/preferences/editor.md').",
+        parameters: z.object({
+            path: z.string().describe("Relative path to the wiki page"),
+        }),
+        handler: async ({ path }) => {
+            const content = deps.wikiRead(path);
+            if (!content)
+                return `Page not found: ${path}`;
+            return content;
+        },
+    });
+    const wikiWrite = defineTool("wiki_write", {
+        description: "Write or update a page in IO's knowledge base. Use this to remember preferences, project details, and important facts. Path must be under pages/ and end in .md.",
+        parameters: z.object({
+            path: z.string().describe("Relative path under pages/ (e.g., 'pages/preferences/clone-location.md')"),
+            content: z.string().describe("Markdown content to write"),
+        }),
+        handler: async ({ path, content }) => {
+            try {
+                deps.wikiAssertPagePath(path);
+                deps.wikiWrite(path, content);
+                return `Written: ${path}`;
+            }
+            catch (err) {
+                return `Error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+    const wikiSearch = defineTool("wiki_search", {
+        description: "Search IO's knowledge base for matching pages.",
+        parameters: z.object({
+            query: z.string().describe("Search query"),
+        }),
+        handler: async ({ query }) => {
+            const results = deps.wikiSearch(query);
+            if (results.length === 0)
+                return "No matching pages found.";
+            return results
+                .map((r) => `**${r.title}** (${r.path})\n${r.snippet}`)
+                .join("\n\n");
+        },
+    });
+    const squadCreate = defineTool("squad_create", {
+        description: "Create a persistent project squad. Squads remember decisions and context for a specific codebase.",
+        parameters: z.object({
+            slug: z.string().describe("Unique identifier (e.g., 'michaeljolley-io')"),
+            name: z.string().describe("Display name (e.g., 'IO Assistant')"),
+            project_path: z.string().describe("Path to the project directory"),
+        }),
+        handler: async ({ slug, name, project_path }) => {
+            try {
+                deps.createSquad(slug, name, project_path);
+                return `Squad "${name}" created for ${project_path}`;
+            }
+            catch (err) {
+                return `Error creating squad: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+    const squadRecall = defineTool("squad_recall", {
+        description: "Recall a squad's context and past decisions. Use this before working on a project to load relevant history.",
+        parameters: z.object({
+            slug: z.string().describe("Squad slug"),
+        }),
+        handler: async ({ slug }) => {
+            const squad = deps.getSquad(slug);
+            if (!squad)
+                return `Squad not found: ${slug}`;
+            const decisions = deps.getDecisionsSummary(slug);
+            return `**Squad: ${squad.name}**\nProject: ${squad.projectPath}\nStatus: ${squad.status}\n\n${decisions}`;
+        },
+    });
+    const squadStatus = defineTool("squad_status", {
+        description: "List all squads and their status.",
+        parameters: z.object({}),
+        handler: async () => {
+            const squads = deps.listSquads();
+            if (squads.length === 0)
+                return "No squads created yet.";
+            return squads
+                .map((s) => `- **${s.name}** (\`${s.slug}\`) — ${s.status} — ${s.projectPath}`)
+                .join("\n");
+        },
+    });
+    const squadLogDecision = defineTool("squad_log_decision", {
+        description: "Log a decision for a squad. Use this to record important choices made during project work.",
+        parameters: z.object({
+            slug: z.string().describe("Squad slug"),
+            decision: z.string().describe("The decision made"),
+            context: z.string().optional().describe("Context or reasoning"),
+        }),
+        handler: async ({ slug, decision, context }) => {
+            try {
+                deps.logDecision(slug, decision, context);
+                return `Decision logged for squad ${slug}`;
+            }
+            catch (err) {
+                return `Error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+    const shell = defineTool("shell", {
+        description: "Run a shell command on the user's machine. Use for git, build tools, file operations, etc.",
+        parameters: z.object({
+            command: z.string().describe("The command to run"),
+            timeout_secs: z.number().optional().describe("Timeout in seconds (default: 60)"),
+            working_dir: z.string().optional().describe("Working directory for the command"),
+        }),
+        handler: async ({ command, timeout_secs, working_dir }) => {
+            try {
+                const result = execSync(command, {
+                    encoding: "utf-8",
+                    timeout: (timeout_secs ?? 60) * 1000,
+                    maxBuffer: 1024 * 1024,
+                    cwd: working_dir,
+                });
+                const output = result.trim();
+                if (output.length > 8000) {
+                    return output.slice(0, 8000) + "\n\n[…truncated]";
+                }
+                return output || "(no output)";
+            }
+            catch (err) {
+                const execErr = err;
+                const stderr = execErr.stderr?.trim() ?? "";
+                const stdout = execErr.stdout?.trim() ?? "";
+                const msg = stderr || stdout || execErr.message || "Command failed";
+                if (msg.length > 4000) {
+                    return `Error:\n${msg.slice(0, 4000)}\n[…truncated]`;
+                }
+                return `Error:\n${msg}`;
+            }
+        },
+    });
+    const webFetch = defineTool("web_fetch", {
+        description: "Fetch a URL and return its content as text.",
+        parameters: z.object({
+            url: z.string().describe("URL to fetch"),
+            max_length: z.number().optional().describe("Max chars to return (default: 5000)"),
+        }),
+        handler: async ({ url, max_length }) => {
+            try {
+                const response = await fetch(url, {
+                    headers: { "User-Agent": "IO-Assistant/1.0" },
+                    signal: AbortSignal.timeout(15000),
+                });
+                if (!response.ok) {
+                    return `HTTP ${response.status}: ${response.statusText}`;
+                }
+                const text = await response.text();
+                const limit = max_length ?? 5000;
+                if (text.length > limit) {
+                    return text.slice(0, limit) + "\n\n[…truncated]";
+                }
+                return text;
+            }
+            catch (err) {
+                return `Fetch error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+    const fileOps = defineTool("file_ops", {
+        description: "Read, write, or list files on the local filesystem.",
+        parameters: z.object({
+            operation: z.enum(["read", "write", "list"]).describe("Operation to perform"),
+            path: z.string().describe("File or directory path"),
+            content: z.string().optional().describe("Content to write (for write operation)"),
+            recursive: z.boolean().optional().describe("Recurse into subdirectories (for list)"),
+        }),
+        handler: async ({ operation, path: filePath, content, recursive }) => {
+            try {
+                const resolved = resolve(filePath);
+                if (operation === "read") {
+                    if (!existsSync(resolved))
+                        return `File not found: ${filePath}`;
+                    const text = readFileSync(resolved, "utf-8");
+                    if (text.length > 8000) {
+                        return text.slice(0, 8000) + "\n\n[…truncated]";
+                    }
+                    return text;
+                }
+                if (operation === "write") {
+                    if (!content)
+                        return "Error: content is required for write operation";
+                    mkdirSync(dirname(resolved), { recursive: true });
+                    writeFileSync(resolved, content, "utf-8");
+                    return `Written: ${filePath}`;
+                }
+                if (operation === "list") {
+                    if (!existsSync(resolved))
+                        return `Directory not found: ${filePath}`;
+                    if (recursive) {
+                        const files = walkDirectory(resolved);
+                        return files.join("\n") || "(empty directory)";
+                    }
+                    const entries = readdirSync(resolved);
+                    return entries
+                        .map((e) => {
+                        const full = join(resolved, e);
+                        const isDir = statSync(full).isDirectory();
+                        return isDir ? `${e}/` : e;
+                    })
+                        .join("\n") || "(empty directory)";
+                }
+                return `Unknown operation: ${operation}`;
+            }
+            catch (err) {
+                return `Error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+    return [wikiRead, wikiWrite, wikiSearch, squadCreate, squadRecall, squadStatus, squadLogDecision, shell, webFetch, fileOps];
+}
+function walkDirectory(dir, maxDepth = 3, depth = 0) {
+    if (depth >= maxDepth)
+        return [];
+    const results = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name.startsWith("."))
+            continue;
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(`${entry.name}/`);
+            results.push(...walkDirectory(full, maxDepth, depth + 1).map((f) => `  ${entry.name}/${f}`));
+        }
+        else {
+            results.push(entry.name);
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=tools.js.map

package/dist/daemon.js

@@ -0,0 +1,145 @@
+import { getClient, stopClient } from "./copilot/client.js";
+import { initOrchestrator, sendToOrchestrator, shutdownOrchestrator } from "./copilot/orchestrator.js";
+import { startApiServer, setMessageHandler as setApiHandler } from "./api/server.js";
+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 { config } from "./config.js";
+import { ensureWikiStructure } from "./wiki/fs.js";
+import { autoUpdate } from "./update.js";
+import { readdirSync, statSync, rmSync } from "fs";
+import { join } from "path";
+import { SESSIONS_DIR } from "./paths.js";
+const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+function pruneOldSessions() {
+    try {
+        const sessionDir = join(SESSIONS_DIR, "session-state");
+        let entries;
+        try {
+            entries = readdirSync(sessionDir);
+        }
+        catch {
+            return;
+        }
+        const cutoff = Date.now() - SEVEN_DAYS_MS;
+        let pruned = 0;
+        for (const entry of entries) {
+            const fullPath = join(sessionDir, entry);
+            try {
+                const stat = statSync(fullPath);
+                if (stat.isDirectory() && stat.mtimeMs < cutoff) {
+                    rmSync(fullPath, { recursive: true, force: true });
+                    pruned++;
+                }
+            }
+            catch { /* skip */ }
+        }
+        if (pruned > 0) {
+            console.log(`[io] Pruned ${pruned} orphaned session folder(s)`);
+        }
+    }
+    catch (err) {
+        console.error("[io] Session pruning failed (non-fatal):", err instanceof Error ? err.message : err);
+    }
+}
+export async function startDaemon() {
+    console.log("[io] Starting IO daemon...");
+    // Auto-update on startup
+    const updated = await autoUpdate();
+    if (updated) {
+        // Re-exec the process with the new version
+        const { spawn } = await import("child_process");
+        const child = spawn(process.execPath, [...process.execArgv, ...process.argv.slice(1)], {
+            detached: true,
+            stdio: "inherit",
+            env: { ...process.env, IO_RESTARTED: "1" },
+        });
+        child.unref();
+        process.exit(0);
+    }
+    if (config.selfEditEnabled) {
+        console.log("[io] ⚠ Self-edit mode enabled");
+    }
+    // Initialize database
+    getDb();
+    console.log("[io] Database initialized");
+    // Initialize wiki
+    const wikiIsNew = ensureWikiStructure();
+    if (wikiIsNew) {
+        console.log("[io] Created wiki at ~/.io/wiki/");
+    }
+    // Clear stale tasks from previous run
+    clearStaleTasks();
+    // Prune old sessions
+    pruneOldSessions();
+    // Start Copilot SDK client
+    console.log("[io] Starting Copilot SDK client...");
+    const client = await getClient();
+    console.log("[io] Copilot SDK client ready");
+    // Initialize orchestrator
+    console.log("[io] Creating orchestrator session...");
+    await initOrchestrator(client);
+    console.log("[io] Orchestrator session ready");
+    // Wire up API message handler
+    setApiHandler(async (text, connectionId, callback) => {
+        await sendToOrchestrator(text, { type: "tui", connectionId }, callback);
+    });
+    // Start HTTP API
+    await startApiServer();
+    // Wire up Telegram handler
+    if (config.telegramEnabled) {
+        setTelegramHandler(async (text, chatId, messageId, callback) => {
+            await sendToOrchestrator(text, { type: "telegram", chatId, messageId }, callback);
+        });
+        createBot();
+        await startBot();
+    }
+    else {
+        console.log("[io] Telegram not configured — skipping bot. Set telegramBotToken in ~/.io/config.json");
+    }
+    console.log("[io] IO is fully operational.");
+    // Notify Telegram if restarting
+    if (config.telegramEnabled && process.env.IO_RESTARTED === "1") {
+        await sendProactiveMessage("I'm back online 🟢").catch(() => { });
+        delete process.env.IO_RESTARTED;
+    }
+}
+// Graceful shutdown
+let shuttingDown = false;
+async function shutdown() {
+    if (shuttingDown) {
+        console.log("\n[io] Forced exit.");
+        process.exit(1);
+    }
+    shuttingDown = true;
+    console.log("\n[io] Shutting down... (Ctrl+C again to force)");
+    const forceTimer = setTimeout(() => {
+        console.log("[io] Shutdown timed out — forcing exit.");
+        process.exit(1);
+    }, 5000);
+    forceTimer.unref();
+    if (config.telegramEnabled) {
+        try {
+            await stopBot();
+        }
+        catch { /* best effort */ }
+    }
+    await shutdownOrchestrator();
+    try {
+        await stopClient();
+    }
+    catch { /* best effort */ }
+    closeDb();
+    console.log("[io] Goodbye.");
+    process.exit(0);
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+process.on("unhandledRejection", (reason) => {
+    console.error("[io] Unhandled rejection (kept alive):", reason);
+});
+process.on("uncaughtException", (err) => {
+    console.error("[io] Uncaught exception — shutting down:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=daemon.js.map

package/dist/index.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { startDaemon } from "./daemon.js";
+import { startTui, setMessageHandler as setTuiHandler } from "./tui/index.js";
+import { sendToOrchestrator, initOrchestrator } from "./copilot/orchestrator.js";
+import { getClient } from "./copilot/client.js";
+import { getDb } from "./store/db.js";
+import { ensureWikiStructure } from "./wiki/fs.js";
+import { startApiServer, setMessageHandler as setApiHandler } from "./api/server.js";
+import { listSkills, installSkill, removeSkill, searchSkillsRegistry } from "./copilot/skills.js";
+import { config, saveConfig } from "./config.js";
+import { createInterface } from "readline";
+const program = new Command();
+program
+    .name("io")
+    .description("IO — personal AI assistant daemon")
+    .version("1.0.0");
+program
+    .option("--daemon", "Run as a background daemon")
+    .option("--self-edit", "Allow IO to modify its own source code")
+    .action(async (opts) => {
+    if (opts.selfEdit) {
+        config.selfEditEnabled = true;
+    }
+    if (opts.daemon) {
+        await startDaemon();
+    }
+    else {
+        // TUI mode — start minimal services and launch interactive chat
+        console.log("[io] Starting IO in interactive mode...");
+        getDb();
+        ensureWikiStructure();
+        const client = await getClient();
+        await initOrchestrator(client);
+        // Wire up API handler for TUI bridge
+        setApiHandler(async (text, connectionId, callback) => {
+            await sendToOrchestrator(text, { type: "tui", connectionId }, callback);
+        });
+        await startApiServer();
+        // Wire up TUI handler
+        setTuiHandler(async (text, callback) => {
+            await sendToOrchestrator(text, { type: "tui", connectionId: "tui-main" }, callback);
+        });
+        await startTui();
+    }
+});
+// Skill management commands
+const skillCmd = program.command("skill").description("Manage IO skills");
+skillCmd
+    .command("list")
+    .description("List installed skills")
+    .action(() => {
+    const skills = listSkills();
+    if (skills.length === 0) {
+        console.log("No skills installed.");
+        return;
+    }
+    for (const s of skills) {
+        console.log(`  ${s.name} (${s.slug})`);
+        if (s.description)
+            console.log(`    ${s.description}`);
+    }
+});
+skillCmd
+    .command("add <repo-url>")
+    .description("Install a skill from a git repository")
+    .action(async (repoUrl) => {
+    try {
+        console.log(`Installing skill from ${repoUrl}...`);
+        const skill = await installSkill(repoUrl);
+        console.log(`✓ Installed: ${skill.name} (${skill.slug})`);
+    }
+    catch (err) {
+        console.error(`✗ ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+});
+skillCmd
+    .command("remove <slug>")
+    .description("Remove an installed skill")
+    .action((slug) => {
+    const removed = removeSkill(slug);
+    if (removed) {
+        console.log(`✓ Removed: ${slug}`);
+    }
+    else {
+        console.log(`Skill not found: ${slug}`);
+    }
+});
+skillCmd
+    .command("search <query>")
+    .description("Search the skills registry")
+    .action(async (query) => {
+    const results = await searchSkillsRegistry(query);
+    if (results.length === 0) {
+        console.log("No skills found.");
+        return;
+    }
+    for (const r of results) {
+        console.log(`  ${r.name}`);
+        console.log(`    ${r.description}`);
+        console.log(`    ${r.repoUrl}`);
+    }
+});
+// Setup command
+program
+    .command("setup")
+    .description("Configure IO (Telegram bot token, user ID, etc.)")
+    .action(async () => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+    console.log("\n🔧 IO Setup\n");
+    const token = await ask(`Telegram Bot Token${config.telegramBotToken ? " (press Enter to keep current)" : ""}: `);
+    if (token.trim()) {
+        config.telegramBotToken = token.trim();
+    }
+    const userId = await ask(`Telegram User ID${config.authorizedUserId ? ` (current: ${config.authorizedUserId})` : ""}: `);
+    if (userId.trim()) {
+        const parsed = parseInt(userId.trim(), 10);
+        if (!isNaN(parsed))
+            config.authorizedUserId = parsed;
+    }
+    config.telegramEnabled = !!(config.telegramBotToken && config.authorizedUserId);
+    saveConfig({
+        telegramBotToken: config.telegramBotToken,
+        authorizedUserId: config.authorizedUserId,
+        telegramEnabled: config.telegramEnabled,
+    });
+    console.log("\n✓ Configuration saved to ~/.io/config.json");
+    if (config.telegramEnabled) {
+        console.log("  Telegram: enabled");
+    }
+    else {
+        console.log("  Telegram: disabled (need both bot token and user ID)");
+    }
+    rl.close();
+});
+program.parse();
+//# sourceMappingURL=index.js.map

package/dist/paths.js

@@ -0,0 +1,10 @@
+import { homedir } from "os";
+import { join } from "path";
+export const IO_HOME = join(homedir(), ".io");
+export const CONFIG_PATH = join(IO_HOME, "config.json");
+export const DB_PATH = join(IO_HOME, "io.db");
+export const WIKI_DIR = join(IO_HOME, "wiki");
+export const SKILLS_DIR = join(IO_HOME, "skills");
+export const SESSIONS_DIR = join(IO_HOME, "sessions");
+export const LOGS_DIR = join(IO_HOME, "logs");
+//# sourceMappingURL=paths.js.map

package/dist/store/db.js

@@ -0,0 +1,101 @@
+import Database from "better-sqlite3";
+import { mkdirSync } from "fs";
+import { DB_PATH, IO_HOME } from "../paths.js";
+let db = null;
+let insertCount = 0;
+export function getDb() {
+    if (db)
+        return db;
+    mkdirSync(IO_HOME, { recursive: true });
+    db = new Database(DB_PATH);
+    db.pragma("journal_mode = WAL");
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS io_state (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS squads (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      slug TEXT UNIQUE NOT NULL,
+      name TEXT NOT NULL,
+      project_path TEXT NOT NULL,
+      copilot_session_id TEXT,
+      status TEXT NOT NULL DEFAULT 'idle',
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS squad_decisions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      squad_slug TEXT NOT NULL,
+      decision TEXT NOT NULL,
+      context TEXT,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS conversation_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
+      content TEXT NOT NULL,
+      source TEXT NOT NULL DEFAULT 'unknown',
+      ts DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS agent_tasks (
+      task_id TEXT PRIMARY KEY,
+      agent_slug TEXT NOT NULL,
+      description TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'running',
+      result TEXT,
+      origin_channel TEXT,
+      started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      completed_at DATETIME
+    );
+  `);
+    return db;
+}
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}
+export function getState(key) {
+    const row = getDb()
+        .prepare("SELECT value FROM io_state WHERE key = ?")
+        .get(key);
+    return row?.value;
+}
+export function setState(key, value) {
+    getDb()
+        .prepare("INSERT INTO io_state (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value")
+        .run(key, value);
+}
+export function deleteState(key) {
+    getDb().prepare("DELETE FROM io_state WHERE key = ?").run(key);
+}
+export function logConversation(role, content, source) {
+    const database = getDb();
+    database
+        .prepare("INSERT INTO conversation_log (role, content, source) VALUES (?, ?, ?)")
+        .run(role, content, source);
+    insertCount++;
+    if (insertCount % 50 === 0) {
+        database
+            .prepare("DELETE FROM conversation_log WHERE id NOT IN (SELECT id FROM conversation_log ORDER BY id DESC LIMIT 1000)")
+            .run();
+    }
+}
+export function getRecentConversation(limit = 50) {
+    const rows = getDb()
+        .prepare("SELECT role, content, source, ts FROM conversation_log ORDER BY id DESC LIMIT ?")
+        .all(limit);
+    return rows.reverse().map((row) => ({
+        ...row,
+        content: row.content.length > 1500
+            ? row.content.slice(0, 1500) + "…"
+            : row.content,
+    }));
+}
+//# sourceMappingURL=db.js.map

package/dist/store/squads.js

@@ -0,0 +1,52 @@
+import { getDb } from "./db.js";
+export function createSquad(slug, name, projectPath) {
+    const db = getDb();
+    db.prepare("INSERT INTO squads (slug, name, project_path) VALUES (?, ?, ?)").run(slug, name, projectPath);
+    return getSquad(slug);
+}
+export function getSquad(slug) {
+    return getDb()
+        .prepare("SELECT * FROM squads WHERE slug = ?")
+        .get(slug);
+}
+export function listSquads() {
+    return getDb().prepare("SELECT * FROM squads ORDER BY created_at DESC").all();
+}
+export function updateSquadSession(slug, sessionId) {
+    getDb()
+        .prepare("UPDATE squads SET copilot_session_id = ?, updated_at = CURRENT_TIMESTAMP WHERE slug = ?")
+        .run(sessionId, slug);
+}
+export function updateSquadStatus(slug, status) {
+    getDb()
+        .prepare("UPDATE squads SET status = ?, updated_at = CURRENT_TIMESTAMP WHERE slug = ?")
+        .run(status, slug);
+}
+export function deleteSquad(slug) {
+    const db = getDb();
+    db.prepare("DELETE FROM squad_decisions WHERE squad_slug = ?").run(slug);
+    db.prepare("DELETE FROM squads WHERE slug = ?").run(slug);
+}
+export function logDecision(squadSlug, decision, context) {
+    getDb()
+        .prepare("INSERT INTO squad_decisions (squad_slug, decision, context) VALUES (?, ?, ?)")
+        .run(squadSlug, decision, context ?? null);
+}
+export function getDecisions(squadSlug, limit = 20) {
+    return getDb()
+        .prepare("SELECT * FROM squad_decisions WHERE squad_slug = ? ORDER BY created_at DESC LIMIT ?")
+        .all(squadSlug, limit);
+}
+export function getDecisionsSummary(squadSlug) {
+    const decisions = getDecisions(squadSlug);
+    if (decisions.length === 0)
+        return "No decisions recorded.";
+    return decisions
+        .reverse()
+        .map((d) => {
+        const ctx = d.context ? ` (${d.context})` : "";
+        return `- [${d.created_at}] ${d.decision}${ctx}`;
+    })
+        .join("\n");
+}
+//# sourceMappingURL=squads.js.map