heyio 0.32.0 → 0.33.1

package/dist/api/mcp.test.js

@@ -0,0 +1,285 @@
+/**
+ * Integration tests for MCP API endpoints (#279).
+ *
+ * Strategy: spin up a minimal Express server that mounts the same MCP route
+ * handlers as src/api/server.ts, but pointed at a temp config file via
+ * setMcpConfigPathForTests(). Tests make real HTTP requests using node:http.
+ * The /mcp/reload endpoint uses an injectable reload fn to avoid pulling in
+ * the full orchestrator (which needs DB + Copilot client).
+ */
+import { describe, it, before, after, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import http from "node:http";
+import express from "express";
+import { setMcpConfigPathForTests, resetMcpConfigPath, loadMcpConfig, saveMcpConfig } from "../mcp/config.js";
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function req(method, port, path, body) {
+    return new Promise((resolve, reject) => {
+        const payload = body !== undefined ? JSON.stringify(body) : undefined;
+        const options = {
+            hostname: "127.0.0.1",
+            port,
+            path,
+            method,
+            headers: {
+                ...(payload ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) } : {}),
+            },
+        };
+        const r = http.request(options, (res) => {
+            let data = "";
+            res.on("data", (chunk) => { data += chunk; });
+            res.on("end", () => {
+                try {
+                    resolve({ status: res.statusCode ?? 0, body: JSON.parse(data) });
+                }
+                catch {
+                    resolve({ status: res.statusCode ?? 0, body: data });
+                }
+            });
+        });
+        r.on("error", reject);
+        if (payload)
+            r.write(payload);
+        r.end();
+    });
+}
+// ── Test server setup ─────────────────────────────────────────────────────────
+let server;
+let port;
+let tmpDir;
+let configPath;
+function buildMcpApp(reloadFn = async () => { }) {
+    const app = express();
+    app.use(express.json());
+    app.get("/api/mcp/servers", (_req, res) => {
+        try {
+            const config = loadMcpConfig();
+            res.json({ servers: config.servers });
+        }
+        catch (e) {
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    app.post("/api/mcp/servers", (req, res) => {
+        const { name, command, args, url, env } = req.body;
+        if (!name) {
+            res.status(400).json({ error: "name is required" });
+            return;
+        }
+        if (!command && !url) {
+            res.status(400).json({ error: "command or url is required" });
+            return;
+        }
+        try {
+            const config = loadMcpConfig();
+            if (config.servers.find(s => s.name === name)) {
+                res.status(409).json({ error: "server already exists" });
+                return;
+            }
+            config.servers.push({ name, command, args, url, env, enabled: true });
+            saveMcpConfig(config);
+            res.status(201).json({ ok: true });
+        }
+        catch (e) {
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    app.delete("/api/mcp/servers/:name", (req, res) => {
+        try {
+            const config = loadMcpConfig();
+            const idx = config.servers.findIndex(s => s.name === req.params.name);
+            if (idx === -1) {
+                res.status(404).json({ error: "server not found" });
+                return;
+            }
+            config.servers.splice(idx, 1);
+            saveMcpConfig(config);
+            res.json({ ok: true });
+        }
+        catch (e) {
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    app.patch("/api/mcp/servers/:name/toggle", (req, res) => {
+        try {
+            const config = loadMcpConfig();
+            const srv = config.servers.find(s => s.name === req.params.name);
+            if (!srv) {
+                res.status(404).json({ error: "server not found" });
+                return;
+            }
+            srv.enabled = srv.enabled === false ? true : false;
+            saveMcpConfig(config);
+            res.json({ ok: true, enabled: srv.enabled });
+        }
+        catch (e) {
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    app.post("/api/mcp/reload", async (_req, res) => {
+        try {
+            await reloadFn();
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err instanceof Error ? err.message : "reload failed" });
+        }
+    });
+    return app;
+}
+before(async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "io-mcp-api-test-"));
+    configPath = join(tmpDir, "mcp.json");
+    setMcpConfigPathForTests(configPath);
+    await new Promise((resolve) => {
+        server = buildMcpApp().listen(0, "127.0.0.1", () => {
+            port = server.address().port;
+            resolve();
+        });
+    });
+});
+after(async () => {
+    await new Promise((resolve, reject) => server.close((e) => e ? reject(e) : resolve()));
+    resetMcpConfigPath();
+    rmSync(tmpDir, { recursive: true, force: true });
+});
+beforeEach(() => {
+    // Reset config file between tests
+    saveMcpConfig({ servers: [] });
+});
+// ── Tests ─────────────────────────────────────────────────────────────────────
+describe("GET /api/mcp/servers", () => {
+    it("returns empty array when no servers configured", async () => {
+        const res = await req("GET", port, "/api/mcp/servers");
+        assert.equal(res.status, 200);
+        assert.deepEqual(res.body.servers, []);
+    });
+    it("returns configured servers", async () => {
+        saveMcpConfig({ servers: [{ name: "figma", command: "npx", enabled: true }] });
+        const res = await req("GET", port, "/api/mcp/servers");
+        assert.equal(res.status, 200);
+        const { servers } = res.body;
+        assert.equal(servers.length, 1);
+        assert.equal(servers[0].name, "figma");
+    });
+});
+describe("POST /api/mcp/servers", () => {
+    it("creates a stdio server successfully", async () => {
+        const res = await req("POST", port, "/api/mcp/servers", {
+            name: "github",
+            command: "npx",
+            args: ["-y", "@modelcontextprotocol/server-github"],
+        });
+        assert.equal(res.status, 201);
+        assert.equal(res.body.ok, true);
+        const config = loadMcpConfig();
+        assert.equal(config.servers.length, 1);
+        assert.equal(config.servers[0].name, "github");
+        assert.equal(config.servers[0].command, "npx");
+        assert.deepEqual(config.servers[0].args, ["-y", "@modelcontextprotocol/server-github"]);
+        assert.equal(config.servers[0].enabled, true);
+    });
+    it("creates an SSE server successfully", async () => {
+        const res = await req("POST", port, "/api/mcp/servers", {
+            name: "postgres",
+            url: "http://localhost:3001/sse",
+        });
+        assert.equal(res.status, 201);
+        const config = loadMcpConfig();
+        assert.equal(config.servers[0].url, "http://localhost:3001/sse");
+    });
+    it("returns 400 when name is missing", async () => {
+        const res = await req("POST", port, "/api/mcp/servers", { command: "npx" });
+        assert.equal(res.status, 400);
+        assert.ok(res.body.error.includes("name"));
+    });
+    it("returns 400 when both command and url are missing", async () => {
+        const res = await req("POST", port, "/api/mcp/servers", { name: "bad-server" });
+        assert.equal(res.status, 400);
+        assert.ok(res.body.error.includes("command"));
+    });
+    it("returns 409 for duplicate server name", async () => {
+        saveMcpConfig({ servers: [{ name: "figma", command: "npx" }] });
+        const res = await req("POST", port, "/api/mcp/servers", { name: "figma", command: "npx" });
+        assert.equal(res.status, 409);
+        assert.ok(res.body.error.includes("already exists"));
+    });
+});
+describe("DELETE /api/mcp/servers/:name", () => {
+    it("removes an existing server", async () => {
+        saveMcpConfig({ servers: [{ name: "figma", command: "npx" }, { name: "postgres", url: "http://localhost/sse" }] });
+        const res = await req("DELETE", port, "/api/mcp/servers/figma");
+        assert.equal(res.status, 200);
+        assert.equal(res.body.ok, true);
+        const config = loadMcpConfig();
+        assert.equal(config.servers.length, 1);
+        assert.equal(config.servers[0].name, "postgres");
+    });
+    it("returns 404 for unknown server", async () => {
+        const res = await req("DELETE", port, "/api/mcp/servers/nonexistent");
+        assert.equal(res.status, 404);
+        assert.ok(res.body.error.includes("not found"));
+    });
+});
+describe("PATCH /api/mcp/servers/:name/toggle", () => {
+    it("disables an enabled server", async () => {
+        saveMcpConfig({ servers: [{ name: "figma", command: "npx", enabled: true }] });
+        const res = await req("PATCH", port, "/api/mcp/servers/figma/toggle");
+        assert.equal(res.status, 200);
+        assert.equal(res.body.enabled, false);
+        assert.equal(loadMcpConfig().servers[0].enabled, false);
+    });
+    it("enables a disabled server", async () => {
+        saveMcpConfig({ servers: [{ name: "figma", command: "npx", enabled: false }] });
+        const res = await req("PATCH", port, "/api/mcp/servers/figma/toggle");
+        assert.equal(res.status, 200);
+        assert.equal(res.body.enabled, true);
+    });
+    it("returns 404 for unknown server", async () => {
+        const res = await req("PATCH", port, "/api/mcp/servers/nonexistent/toggle");
+        assert.equal(res.status, 404);
+        assert.ok(res.body.error.includes("not found"));
+    });
+});
+describe("POST /api/mcp/reload", () => {
+    it("calls reload function and returns ok", async () => {
+        let reloadCalled = false;
+        const app = buildMcpApp(async () => { reloadCalled = true; });
+        await new Promise((resolve, reject) => {
+            const s = app.listen(0, "127.0.0.1", async () => {
+                const p = s.address().port;
+                try {
+                    const res = await req("POST", p, "/api/mcp/reload");
+                    assert.equal(res.status, 200);
+                    assert.equal(res.body.ok, true);
+                    assert.ok(reloadCalled, "reload function should have been called");
+                }
+                finally {
+                    s.close(() => resolve());
+                }
+            });
+            s.on("error", reject);
+        });
+    });
+    it("returns 500 when reload throws", async () => {
+        const app = buildMcpApp(async () => { throw new Error("init failed"); });
+        await new Promise((resolve, reject) => {
+            const s = app.listen(0, "127.0.0.1", async () => {
+                const p = s.address().port;
+                try {
+                    const res = await req("POST", p, "/api/mcp/reload");
+                    assert.equal(res.status, 500);
+                    assert.ok(res.body.error.includes("init failed"));
+                }
+                finally {
+                    s.close(() => resolve());
+                }
+            });
+            s.on("error", reject);
+        });
+    });
+});
+//# sourceMappingURL=mcp.test.js.map

package/dist/copilot/agents.js

@@ -17,6 +17,7 @@ import { removeWorktree } from "../store/worktrees.js";
 import { createFeedEntry } from "../store/feed.js";
 import { SESSIONS_DIR } from "../paths.js";
 import { getUniverse } from "./universes.js";
+import { readSquadWikiPages } from "../wiki/fs.js";
 // Key format: "squadSlug:characterName" for per-agent sessions, "squadSlug" for legacy
 const agentSessions = new Map();
 const agentSessionModels = new Map();
@@ -417,6 +418,10 @@ async function getOrCreateAgentSession(squadSlug, agent, taskDescription) {
     const squad = getSquad(squadSlug);
     const client = await getClient();
     const decisions = getDecisionsSummary(squadSlug);
+    const wikiPages = readSquadWikiPages(squadSlug);
+    const wikiSection = wikiPages.length > 0
+        ? `\n\n## Squad Wiki\n${wikiPages.map(p => `### ${p.path}\n${p.content}`).join("\n\n")}`
+        : "";
     console.error(`[io] Agent ${agent.character_name}: using model "${model}" (agent tier: ${agentTier}, task tier: ${taskTier}, effective: ${effectiveTier})`);
     const universeName = squad.universe
         ? getUniverse(squad.universe)?.name ?? squad.universe
@@ -479,7 +484,7 @@ ${agent.charter ?? "General-purpose agent. Handle tasks as they come."}
 - **Path**: ${squad.project_path}
 
 ## Past Decisions
-${decisions}${leadSection}
+${decisions}${leadSection}${wikiSection}
 
 ## Repository Hygiene
 Before you make ANY code changes, you MUST sync your working copy with the remote default branch and work from a fresh feature branch. This prevents the merge conflicts the team hit on PRs like #45.
@@ -537,6 +542,10 @@ async function getOrCreateSession(squadSlug, taskDescription) {
     const squad = getSquad(squadSlug);
     const client = await getClient();
     const decisions = getDecisionsSummary(squadSlug);
+    const wikiPages = readSquadWikiPages(squadSlug);
+    const wikiSection = wikiPages.length > 0
+        ? `\n\n## Squad Wiki\n${wikiPages.map(p => `### ${p.path}\n${p.content}`).join("\n\n")}`
+        : "";
     const agentTools = buildAgentTools(squadSlug);
     const model = getModelForTask(taskDescription ?? "", squad.model);
     const commonConfig = {
@@ -738,27 +747,50 @@ function buildAgentTools(squadSlug, isLead = false) {
                     updateAgentStatus(squadSlug, teammateAgent.character_name, "working");
                     try {
                         const session = await getOrCreateAgentSession(squadSlug, teammateAgent, task);
-                        const envelopedTask = buildTaskPromptEnvelope(squadSlug, task);
-                        // Idle-reset timeout: 10min between progress events, 30min
-                        // hard cap. (Issue #53 — replaces #51's 30min wall-clock cap
-                        // that still killed agents mid-tool-call when they had
-                        // long-running shell work between assistant messages.)
-                        const sendResult = await sendWithIdleTimeout(session, envelopedTask, {
-                            idleMs: 10 * 60_000,
-                            hardCapMs: 30 * 60_000,
-                            onIdleTimeout: ({ lastEventType }) => {
-                                console.error(`[io] Teammate ${teammateAgent.character_name} idle (last event: ${lastEventType ?? "none"}) — aborting.`);
-                            },
+                        recordTaskEvent(childTaskId, {
+                            ts: Date.now(),
+                            type: "task.start",
+                            data: { taskId: childTaskId, agentKey: childAgentKey, description: task },
                         });
-                        const result = sendResult.content || "(teammate returned no output)";
-                        updateAgentStatus(squadSlug, teammateAgent.character_name, "idle");
-                        if (sendResult.timedOut) {
-                            const stamped = `[teammate timed out — ${sendResult.timeoutReason === "idle" ? "idle reset" : "hard cap"}; last event: ${sendResult.lastEventType ?? "none"}]\n\n${result}`;
-                            failTask(childTaskId, stamped);
-                            return stamped;
+                        let unsubChild;
+                        try {
+                            unsubChild = session.on((event) => {
+                                if (!STREAM_EVENT_TYPES.has(event.type))
+                                    return;
+                                recordTaskEvent(childTaskId, {
+                                    ts: Date.now(),
+                                    type: event.type,
+                                    data: event.data ?? null,
+                                });
+                            });
+                            const envelopedTask = buildTaskPromptEnvelope(squadSlug, task);
+                            // Idle-reset timeout: 10min between progress events, 30min
+                            // hard cap. (Issue #53 — replaces #51's 30min wall-clock cap
+                            // that still killed agents mid-tool-call when they had
+                            // long-running shell work between assistant messages.)
+                            const sendResult = await sendWithIdleTimeout(session, envelopedTask, {
+                                idleMs: 10 * 60_000,
+                                hardCapMs: 30 * 60_000,
+                                onIdleTimeout: ({ lastEventType }) => {
+                                    console.error(`[io] Teammate ${teammateAgent.character_name} idle (last event: ${lastEventType ?? "none"}) — aborting.`);
+                                },
+                            });
+                            const result = sendResult.content || "(teammate returned no output)";
+                            updateAgentStatus(squadSlug, teammateAgent.character_name, "idle");
+                            if (sendResult.timedOut) {
+                                const stamped = `[teammate timed out — ${sendResult.timeoutReason === "idle" ? "idle reset" : "hard cap"}; last event: ${sendResult.lastEventType ?? "none"}]\n\n${result}`;
+                                failTask(childTaskId, stamped);
+                                return stamped;
+                            }
+                            completeTask(childTaskId, result);
+                            return result;
+                        }
+                        finally {
+                            try {
+                                unsubChild?.();
+                            }
+                            catch { /* best-effort cleanup */ }
                         }
-                        completeTask(childTaskId, result);
-                        return result;
                     }
                     catch (err) {
                         updateAgentStatus(squadSlug, teammateAgent.character_name, "error");

package/dist/copilot/orchestrator.js

@@ -347,7 +347,7 @@ function invalidateSession() {
 // ---------------------------------------------------------------------------
 // Message execution
 // ---------------------------------------------------------------------------
-async function executeOnSession(prompt, callback) {
+async function executeOnSession(prompt, callback, attachments) {
     const session = await ensureOrchestratorSession();
     let accumulated = "";
     const unsubDelta = session.on("assistant.message_delta", (event) => {
@@ -356,7 +356,10 @@ async function executeOnSession(prompt, callback) {
         callback(delta, false);
     });
     try {
-        const result = await session.sendAndWait({ prompt }, SEND_TIMEOUT_MS);
+        const sendPayload = { prompt };
+        if (attachments && attachments.length > 0)
+            sendPayload.attachments = attachments;
+        const result = await session.sendAndWait(sendPayload, SEND_TIMEOUT_MS);
         unsubDelta();
         const finalText = result?.data.content ?? accumulated;
         callback("", true);
@@ -412,7 +415,7 @@ async function processQueue() {
             let lastError;
             for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
                 try {
-                    const response = await executeOnSession(taggedPrompt, msg.callback);
+                    const response = await executeOnSession(taggedPrompt, msg.callback, msg.attachments);
                     logConversation("assistant", response, sourceLabel(msg.source));
                     msg.resolve();
                     lastError = undefined;
@@ -507,10 +510,10 @@ export async function initOrchestrator(copilotClient) {
         console.error("[io] Eager session creation failed (will retry on first message):", err instanceof Error ? err.message : err);
     }
 }
-export async function sendToOrchestrator(prompt, source, callback) {
+export async function sendToOrchestrator(prompt, source, callback, attachments) {
     logConversation("user", prompt, sourceLabel(source));
     return new Promise((resolve, reject) => {
-        messageQueue.push({ prompt, source, callback, resolve, reject });
+        messageQueue.push({ prompt, source, callback, attachments, resolve, reject });
         processQueue();
     });
 }

package/dist/daemon.js

@@ -110,8 +110,8 @@ export async function startDaemon() {
     await startApiServer();
     // Wire up Telegram handler
     if (config.telegramEnabled) {
-        setTelegramHandler(async (text, chatId, messageId, callback) => {
-            await sendToOrchestrator(text, { type: "telegram", chatId, messageId }, callback);
+        setTelegramHandler(async (text, chatId, messageId, callback, attachments) => {
+            await sendToOrchestrator(text, { type: "telegram", chatId, messageId }, callback, attachments);
         });
         createBot();
         await startBot();

package/dist/mcp/config.js

@@ -3,12 +3,20 @@ import { dirname } from "path";
 import { IO_HOME } from "../paths.js";
 import { join } from "path";
 export const MCP_CONFIG_PATH = join(IO_HOME, "mcp.json");
+// Mutable override for tests — mirrors the setDbPathForTests pattern.
+let _configPath = MCP_CONFIG_PATH;
+export function setMcpConfigPathForTests(path) {
+    _configPath = path;
+}
+export function resetMcpConfigPath() {
+    _configPath = MCP_CONFIG_PATH;
+}
 export function loadMcpConfig() {
-    if (!existsSync(MCP_CONFIG_PATH)) {
+    if (!existsSync(_configPath)) {
         return { servers: [] };
     }
     try {
-        const raw = readFileSync(MCP_CONFIG_PATH, "utf-8");
+        const raw = readFileSync(_configPath, "utf-8");
         const parsed = JSON.parse(raw);
         if (!parsed.servers || !Array.isArray(parsed.servers)) {
             return { servers: [] };
@@ -20,10 +28,10 @@ export function loadMcpConfig() {
     }
 }
 export function saveMcpConfig(config) {
-    const dir = dirname(MCP_CONFIG_PATH);
+    const dir = dirname(_configPath);
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
-    writeFileSync(MCP_CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+    writeFileSync(_configPath, JSON.stringify(config, null, 2), "utf-8");
 }
 //# sourceMappingURL=config.js.map

package/dist/store/instances.js

@@ -1,6 +1,7 @@
 import { getDb } from "./db.js";
 import { getDecisions } from "./squads.js";
 import { worktreeExists } from "./worktrees.js";
+import { readSquadWikiPages } from "../wiki/fs.js";
 export function ensureInstanceTables() {
     const db = getDb();
     db.exec(`
@@ -108,7 +109,14 @@ export function deleteInstance(id) {
  */
 export function buildContextSnapshot(masterSquadSlug, limit = 30) {
     const decisions = getDecisions(masterSquadSlug, limit);
-    return JSON.stringify(decisions.map((d) => ({ decision: d.decision, context: d.context, created_at: d.created_at })));
+    const wikiPages = readSquadWikiPages(masterSquadSlug);
+    const snapshot = {
+        decisions: decisions.map((d) => ({ decision: d.decision, context: d.context, created_at: d.created_at })),
+    };
+    if (wikiPages.length > 0) {
+        snapshot.wiki = wikiPages.map(p => ({ path: p.path, content: p.content }));
+    }
+    return JSON.stringify(snapshot);
 }
 /**
  * Reconcile instances on startup: detect orphaned worktrees and mark stale active instances.

package/dist/store/instances.test.js

@@ -234,18 +234,19 @@ describe("deleteInstance", () => {
 });
 // ── buildContextSnapshot ──────────────────────────────────────────────────────
 describe("buildContextSnapshot", () => {
-    it("returns a JSON array of recent squad decisions", () => {
+    it("returns a JSON object with decisions array", () => {
         logDecision("test-squad", "use TypeScript everywhere", "consistency");
         logDecision("test-squad", "prefer functional style");
         const snapshot = buildContextSnapshot("test-squad");
         const parsed = JSON.parse(snapshot);
-        assert.ok(Array.isArray(parsed));
-        assert.equal(parsed.length, 2);
-        assert.ok(parsed.some((d) => d.decision === "use TypeScript everywhere"));
+        assert.ok(Array.isArray(parsed.decisions));
+        assert.equal(parsed.decisions.length, 2);
+        assert.ok(parsed.decisions.some((d) => d.decision === "use TypeScript everywhere"));
     });
-    it("returns an empty JSON array for a squad with no decisions", () => {
+    it("returns empty decisions array for a squad with no decisions", () => {
         const snapshot = buildContextSnapshot("test-squad");
-        assert.deepEqual(JSON.parse(snapshot), []);
+        const parsed = JSON.parse(snapshot);
+        assert.deepEqual(parsed.decisions, []);
     });
     it("respects the limit parameter", () => {
         for (let i = 0; i < 10; i++) {
@@ -253,7 +254,25 @@ describe("buildContextSnapshot", () => {
         }
         const snapshot = buildContextSnapshot("test-squad", 5);
         const parsed = JSON.parse(snapshot);
-        assert.equal(parsed.length, 5);
+        assert.equal(parsed.decisions.length, 5);
+    });
+    it("includes wiki pages when they exist", async () => {
+        const { writePage, deletePage } = await import("../wiki/fs.js");
+        const testSlug = `test-squad-snap-${Date.now()}`;
+        const pagePath = `pages/squads/${testSlug}/rules.md`;
+        try {
+            writePage(pagePath, "# Rules\nNo force push.");
+            logDecision(testSlug, "test decision");
+            const snapshot = buildContextSnapshot(testSlug);
+            const parsed = JSON.parse(snapshot);
+            assert.ok(parsed.wiki);
+            assert.equal(parsed.wiki.length, 1);
+            assert.equal(parsed.wiki[0].path, pagePath);
+            assert.ok(parsed.wiki[0].content.includes("No force push"));
+        }
+        finally {
+            deletePage(pagePath);
+        }
     });
 });
 // ── reconcileInstances ────────────────────────────────────────────────────────

package/dist/telegram/bot.js

@@ -2,8 +2,17 @@ import { Bot } from "grammy";
 import { config } from "../config.js";
 const TELEGRAM_MAX_LENGTH = 4096;
 const EDIT_DEBOUNCE_MS = 500;
+const FILE_SIZE_LIMIT_BYTES = 5 * 1024 * 1024; // 5MB
 let bot;
 let messageHandler;
+async function downloadTelegramFile(botInstance, fileId) {
+    const file = await botInstance.api.getFile(fileId);
+    const url = `https://api.telegram.org/file/bot${config.telegramBotToken}/${file.file_path}`;
+    const response = await fetch(url);
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const mimeType = response.headers.get("content-type") ?? "application/octet-stream";
+    return { data: buffer.toString("base64"), mimeType, size: buffer.length };
+}
 export function setMessageHandler(handler) {
     messageHandler = handler;
 }
@@ -82,6 +91,172 @@ export function createBot() {
             await editReply("An error occurred while processing your message.");
         }
     });
+    // ---------------------------------------------------------------------------
+    // Photo handler
+    // ---------------------------------------------------------------------------
+    bot.on("message:photo", async (ctx) => {
+        const userId = ctx.from?.id;
+        if (config.authorizedUserId && userId !== config.authorizedUserId)
+            return;
+        if (!messageHandler || !bot) {
+            console.error("[io] No message handler registered");
+            return;
+        }
+        // Telegram sends an array of sizes — last element is the highest resolution
+        const photos = ctx.message.photo;
+        const photo = photos[photos.length - 1];
+        const chatId = ctx.chat.id;
+        const messageId = ctx.message.message_id;
+        const caption = ctx.message.caption ?? "";
+        await ctx.replyWithChatAction("typing");
+        const ack = await ctx.reply("📎 Processing attachment…");
+        try {
+            const { data, mimeType, size } = await downloadTelegramFile(bot, photo.file_id);
+            if (size > FILE_SIZE_LIMIT_BYTES) {
+                await ctx.api.editMessageText(chatId, ack.message_id, "⚠️ File too large (max 5MB). Attachment not processed.");
+                return;
+            }
+            const attachment = { type: "blob", data, mimeType, displayName: "photo.jpg" };
+            const placeholder = await ctx.reply("…");
+            let accumulated = "";
+            let lastEditTime = 0;
+            let pendingEdit;
+            const editReply = async (content) => {
+                try {
+                    const truncated = content.length > TELEGRAM_MAX_LENGTH
+                        ? content.slice(0, TELEGRAM_MAX_LENGTH - 20) + "\n\n[…truncated]"
+                        : content;
+                    await ctx.api.editMessageText(chatId, placeholder.message_id, truncated);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    if (!message.includes("message is not modified")) {
+                        console.error("[io] Failed to edit message:", message);
+                    }
+                }
+            };
+            await ctx.api.deleteMessage(chatId, ack.message_id);
+            await messageHandler(caption, chatId, messageId, (chunk, done) => {
+                accumulated += chunk;
+                if (done) {
+                    if (pendingEdit) {
+                        clearTimeout(pendingEdit);
+                        pendingEdit = undefined;
+                    }
+                    return;
+                }
+                const now = Date.now();
+                const timeSinceLastEdit = now - lastEditTime;
+                if (timeSinceLastEdit >= EDIT_DEBOUNCE_MS) {
+                    lastEditTime = now;
+                    void editReply(accumulated);
+                }
+                else if (!pendingEdit) {
+                    pendingEdit = setTimeout(() => {
+                        pendingEdit = undefined;
+                        lastEditTime = Date.now();
+                        void editReply(accumulated);
+                    }, EDIT_DEBOUNCE_MS - timeSinceLastEdit);
+                }
+            }, [attachment]);
+            if (pendingEdit)
+                clearTimeout(pendingEdit);
+            if (accumulated.length > 0)
+                await editReply(accumulated);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error("[io] Error handling photo:", message);
+            await ctx.api.editMessageText(chatId, ack.message_id, "An error occurred while processing the attachment.");
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // Document handler
+    // ---------------------------------------------------------------------------
+    bot.on("message:document", async (ctx) => {
+        const userId = ctx.from?.id;
+        if (config.authorizedUserId && userId !== config.authorizedUserId)
+            return;
+        if (!messageHandler || !bot) {
+            console.error("[io] No message handler registered");
+            return;
+        }
+        const doc = ctx.message.document;
+        const chatId = ctx.chat.id;
+        const messageId = ctx.message.message_id;
+        const caption = ctx.message.caption ?? "";
+        // Reject oversized files before downloading (file_size may be undefined for large files)
+        if (doc.file_size !== undefined && doc.file_size > FILE_SIZE_LIMIT_BYTES) {
+            await ctx.reply("⚠️ File too large (max 5MB). Attachment not processed.");
+            return;
+        }
+        await ctx.replyWithChatAction("typing");
+        const ack = await ctx.reply("📎 Processing attachment…");
+        try {
+            const { data, mimeType, size } = await downloadTelegramFile(bot, doc.file_id);
+            if (size > FILE_SIZE_LIMIT_BYTES) {
+                await ctx.api.editMessageText(chatId, ack.message_id, "⚠️ File too large (max 5MB). Attachment not processed.");
+                return;
+            }
+            const attachment = {
+                type: "blob",
+                data,
+                mimeType,
+                displayName: doc.file_name ?? "document",
+            };
+            const placeholder = await ctx.reply("…");
+            let accumulated = "";
+            let lastEditTime = 0;
+            let pendingEdit;
+            const editReply = async (content) => {
+                try {
+                    const truncated = content.length > TELEGRAM_MAX_LENGTH
+                        ? content.slice(0, TELEGRAM_MAX_LENGTH - 20) + "\n\n[…truncated]"
+                        : content;
+                    await ctx.api.editMessageText(chatId, placeholder.message_id, truncated);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    if (!message.includes("message is not modified")) {
+                        console.error("[io] Failed to edit message:", message);
+                    }
+                }
+            };
+            await ctx.api.deleteMessage(chatId, ack.message_id);
+            await messageHandler(caption, chatId, messageId, (chunk, done) => {
+                accumulated += chunk;
+                if (done) {
+                    if (pendingEdit) {
+                        clearTimeout(pendingEdit);
+                        pendingEdit = undefined;
+                    }
+                    return;
+                }
+                const now = Date.now();
+                const timeSinceLastEdit = now - lastEditTime;
+                if (timeSinceLastEdit >= EDIT_DEBOUNCE_MS) {
+                    lastEditTime = now;
+                    void editReply(accumulated);
+                }
+                else if (!pendingEdit) {
+                    pendingEdit = setTimeout(() => {
+                        pendingEdit = undefined;
+                        lastEditTime = Date.now();
+                        void editReply(accumulated);
+                    }, EDIT_DEBOUNCE_MS - timeSinceLastEdit);
+                }
+            }, [attachment]);
+            if (pendingEdit)
+                clearTimeout(pendingEdit);
+            if (accumulated.length > 0)
+                await editReply(accumulated);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error("[io] Error handling document:", message);
+            await ctx.api.editMessageText(chatId, ack.message_id, "An error occurred while processing the attachment.");
+        }
+    });
     bot.catch((err) => {
         console.error("[io] Grammy bot error:", err.message);
     });

package/dist/wiki/fs.js

@@ -149,4 +149,15 @@ export function writeLogFile(content) {
 export function getWikiDir() {
     return WIKI_DIR;
 }
+/**
+ * Read all wiki pages for a squad by slug.
+ * Returns array of { path, content } for pages under pages/squads/{slug}/.
+ */
+export function readSquadWikiPages(slug) {
+    const prefix = `pages/squads/${slug}/`;
+    return listPages()
+        .filter(p => p.startsWith(prefix))
+        .map(p => ({ path: p, content: readPage(p) ?? "" }))
+        .filter(entry => entry.content.length > 0);
+}
 //# sourceMappingURL=fs.js.map

package/dist/wiki/wiki-squad.test.js

@@ -0,0 +1,54 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readSquadWikiPages, writePage, deletePage } from "./fs.js";
+describe("readSquadWikiPages", () => {
+    it("returns empty array for non-existent squad", () => {
+        const pages = readSquadWikiPages("nonexistent-squad-xyz");
+        assert.ok(Array.isArray(pages));
+        assert.equal(pages.length, 0);
+    });
+    it("returns pages under pages/squads/{slug}/ prefix", () => {
+        const testSlug = `test-squad-${Date.now()}`;
+        const pagePath = `pages/squads/${testSlug}/workflow.md`;
+        try {
+            writePage(pagePath, "# Workflow Rules\nAlways use feature branches.");
+            const pages = readSquadWikiPages(testSlug);
+            assert.equal(pages.length, 1);
+            assert.equal(pages[0].path, pagePath);
+            assert.ok(pages[0].content.includes("feature branches"));
+        }
+        finally {
+            deletePage(pagePath);
+        }
+    });
+    it("filters out empty pages", () => {
+        const testSlug = `test-squad-empty-${Date.now()}`;
+        const pagePath = `pages/squads/${testSlug}/empty.md`;
+        try {
+            writePage(pagePath, "");
+            const pages = readSquadWikiPages(testSlug);
+            assert.equal(pages.length, 0);
+        }
+        finally {
+            deletePage(pagePath);
+        }
+    });
+    it("returns multiple pages for a squad", () => {
+        const testSlug = `test-squad-multi-${Date.now()}`;
+        const page1 = `pages/squads/${testSlug}/workflow.md`;
+        const page2 = `pages/squads/${testSlug}/coding-standards.md`;
+        try {
+            writePage(page1, "# Workflow\nUse PRs.");
+            writePage(page2, "# Standards\nESLint required.");
+            const pages = readSquadWikiPages(testSlug);
+            assert.equal(pages.length, 2);
+            const paths = pages.map(p => p.path).sort();
+            assert.deepEqual(paths, [page2, page1].sort());
+        }
+        finally {
+            deletePage(page1);
+            deletePage(page2);
+        }
+    });
+});
+//# sourceMappingURL=wiki-squad.test.js.map

package/package.json

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