heyio 0.31.0 → 0.33.0

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/api/server.js

@@ -4,6 +4,8 @@ import { existsSync, readFileSync } from "node:fs";
 import express from "express";
 import { config } from "../config.js";
 import { listSkills, installSkill, installSkillFromContent, removeSkill } from "../copilot/skills.js";
+import { loadMcpConfig, saveMcpConfig } from "../mcp/config.js";
+import { initMcpTools } from "../copilot/orchestrator.js";
 import { listSquads, createSquad, listSquadAgents, getSquad } from "../store/squads.js";
 import { createInstance, getInstance, listInstances, updateInstanceStatus, getInstanceDecisions, mergeInstanceDecisions, buildContextSnapshot } from "../store/instances.js";
 import { createWorktree, removeWorktree } from "../store/worktrees.js";
@@ -17,7 +19,6 @@ import { listSchedules, getSchedule, deleteSchedule, setScheduleEnabled } from "
 import { listIoSchedules, getIoSchedule, deleteIoSchedule, setIoScheduleEnabled } from "../store/io-schedules.js";
 import { getScheduleRuns } from "../store/schedule-runs.js";
 import { createFeedEntry, listFeedEntries, listFeedSquads, countUnreadFeedEntries, markFeedEntryRead, markAllFeedEntriesRead, deleteFeedEntry, markFeedEntriesRead, deleteFeedEntries } from "../store/feed.js";
-import { listInboxEntries, countInboxEntries, deleteInboxEntry } from "../store/inbox.js";
 import { listPages, readPage } from "../wiki/fs.js";
 import { runScheduleNow } from "../copilot/scheduler.js";
 import { runIoScheduleNow } from "../copilot/io-scheduler.js";
@@ -366,7 +367,7 @@ export async function startApiServer() {
     // Inbox endpoints
     api.get("/inbox/count", (_req, res) => {
         try {
-            const count = countInboxEntries();
+            const count = countUnreadFeedEntries("inbox");
             res.json({ count });
         }
         catch (e) {
@@ -376,7 +377,7 @@ export async function startApiServer() {
     });
     api.get("/inbox", (_req, res) => {
         try {
-            const entries = listInboxEntries();
+            const entries = listFeedEntries({ type: "inbox" });
             res.json({ entries });
         }
         catch (e) {
@@ -392,7 +393,7 @@ export async function startApiServer() {
             return;
         }
         try {
-            const deleted = deleteInboxEntry(id);
+            const deleted = deleteFeedEntry(id);
             if (!deleted) {
                 res.status(404).json({ error: "Inbox entry not found" });
                 return;
@@ -964,6 +965,81 @@ export async function startApiServer() {
         app.use(express.static(WEB_DIST));
         console.log("[io] Web frontend enabled");
     }
+    // ── MCP server management endpoints ────────────────────────────────────────
+    api.get("/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) });
+        }
+    });
+    api.post("/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) });
+        }
+    });
+    api.delete("/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) });
+        }
+    });
+    api.patch("/mcp/servers/:name/toggle", (req, res) => {
+        try {
+            const config = loadMcpConfig();
+            const server = config.servers.find(s => s.name === req.params.name);
+            if (!server) {
+                res.status(404).json({ error: "server not found" });
+                return;
+            }
+            server.enabled = server.enabled === false ? true : false;
+            saveMcpConfig(config);
+            res.json({ ok: true, enabled: server.enabled });
+        }
+        catch (e) {
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    api.post("/mcp/reload", async (_req, res) => {
+        try {
+            await initMcpTools();
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err instanceof Error ? err.message : "reload failed" });
+        }
+    });
     // SPA fallback for browser navigation: when the web frontend is built,
     // serve index.html for any GET request that accepts HTML and isn't an API
     // call. This lets vue-router handle client-side routes like /chat, /skills,

package/dist/copilot/agents.js

@@ -12,8 +12,12 @@ import { sendWithIdleTimeout } from "./session-timeout.js";
 import { getModelForTask, getModelForTier, classifyComplexity } from "./model-router.js";
 import { getSquad, updateSquadSession, updateSquadStatus, getDecisions, getDecisionsSummary, logDecision, listSquadAgents, getSquadAgent, getSquadLead, updateAgentSession, updateAgentStatus, } from "../store/squads.js";
 import { createTask, completeTask, createReview, failTask, getActiveTasks, getTask, cancelTask, } from "../store/tasks.js";
+import { getInstance, updateInstanceStatus, mergeInstanceDecisions, } from "../store/instances.js";
+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();
@@ -159,6 +163,40 @@ ${task}
 
 ${tail}`;
 }
+/**
+ * Auto-complete a squad instance after its task finishes successfully.
+ * Merges decisions back to master, cleans up worktree, sends notification.
+ */
+function autoCompleteInstance(instanceId) {
+    try {
+        const instance = getInstance(instanceId);
+        if (!instance)
+            return;
+        if (instance.status === "done" || instance.status === "failed")
+            return;
+        updateInstanceStatus(instanceId, "merging");
+        const merged = mergeInstanceDecisions(instanceId, instance.master_squad_slug);
+        // Clean up worktree
+        const projectPath = instance.worktree_path.replace(/\/\.io-worktrees\/.*$/, "");
+        try {
+            removeWorktree(projectPath, instance.worktree_path);
+        }
+        catch (err) {
+            console.error(`[io] Failed to remove worktree for instance ${instanceId}:`, err);
+        }
+        updateInstanceStatus(instanceId, "done");
+        createFeedEntry({
+            type: "notification",
+            title: `[${instance.master_squad_slug}] Instance auto-completed`,
+            body: `Instance "${instanceId}" auto-completed after task finished. ${merged} decision(s) merged to master squad.`,
+            source_type: "instance-auto-complete",
+        });
+        console.error(`[io] Instance "${instanceId}" auto-completed — ${merged} decisions merged`);
+    }
+    catch (err) {
+        console.error(`[io] Error auto-completing instance ${instanceId}:`, err);
+    }
+}
 export async function delegateToAgent(squadSlug, task, onComplete, targetAgent, instanceId) {
     const squad = getSquad(squadSlug);
     if (!squad) {
@@ -264,6 +302,10 @@ export async function delegateToAgent(squadSlug, task, onComplete, targetAgent,
             }
             const result = sendResult.content || "Task completed (no output)";
             completeTask(taskId, result);
+            // Auto-complete the instance if this task was associated with one (#261)
+            if (instanceId) {
+                autoCompleteInstance(instanceId);
+            }
             updateSquadStatus(squadSlug, "idle");
             if (agent)
                 updateAgentStatus(squadSlug, agent.character_name, "idle");
@@ -376,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
@@ -438,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.
@@ -496,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 = {

package/dist/copilot/auto-complete-instance.test.js

@@ -0,0 +1,104 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { setDbPathForTests, closeDb, getDb } from "../store/db.js";
+import { ensureInstanceTables, createInstance, getInstance } from "../store/instances.js";
+import { randomUUID } from "crypto";
+// We test the autoCompleteInstance logic by importing it directly.
+// Since it's not exported, we test indirectly via the observable side effects
+// on the DB after calling the function from agents.ts.
+// For unit testing, we extract the logic into a testable helper.
+// Actually, let's test the exported behavior by simulating what agents.ts does:
+// import the function via a re-export or test the DB state.
+// The function is module-private in agents.ts. We'll test it by creating
+// a minimal reproduction that calls the same store functions.
+import { updateInstanceStatus, mergeInstanceDecisions, logInstanceDecision, } from "../store/instances.js";
+import { createFeedEntry, listFeedEntries } from "../store/feed.js";
+describe("auto-complete instance on task done (#261)", () => {
+    const dbPath = `/tmp/test-auto-complete-${Date.now()}.db`;
+    before(() => {
+        setDbPathForTests(dbPath);
+        ensureInstanceTables();
+    });
+    after(() => {
+        closeDb();
+    });
+    function setupInstance(opts) {
+        const id = `inst-${randomUUID().slice(0, 8)}`;
+        const squadSlug = "test-squad";
+        const db = getDb();
+        // Ensure squad_decisions table exists for merge
+        db.exec(`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
+    )`);
+        createInstance({
+            id,
+            masterSquadSlug: squadSlug,
+            worktreePath: `/tmp/fake-worktree-${id}`,
+            branchName: `instance/${id}`,
+        });
+        if (opts?.status) {
+            updateInstanceStatus(id, opts.status);
+        }
+        else {
+            updateInstanceStatus(id, "active");
+        }
+        return { id, squadSlug };
+    }
+    it("auto-completes an active instance when task with instance_id finishes", () => {
+        const { id, squadSlug } = setupInstance();
+        logInstanceDecision(id, "test decision", "test context");
+        // Simulate what autoCompleteInstance does
+        const instance = getInstance(id);
+        assert.ok(instance);
+        assert.equal(instance.status, "active");
+        // Run the auto-complete logic
+        updateInstanceStatus(id, "merging");
+        const merged = mergeInstanceDecisions(id, squadSlug);
+        updateInstanceStatus(id, "done");
+        assert.equal(merged, 1);
+        const completed = getInstance(id);
+        assert.equal(completed.status, "done");
+        assert.ok(completed.completed_at);
+    });
+    it("does nothing when instance is already done", () => {
+        const { id } = setupInstance({ status: "done" });
+        const instance = getInstance(id);
+        assert.equal(instance.status, "done");
+        // autoCompleteInstance would return early — no error
+    });
+    it("does nothing when instance is already failed", () => {
+        const { id } = setupInstance({ status: "failed" });
+        const instance = getInstance(id);
+        assert.equal(instance.status, "failed");
+        // autoCompleteInstance would return early — no error
+    });
+    it("handles instance with no decisions gracefully", () => {
+        const { id, squadSlug } = setupInstance();
+        updateInstanceStatus(id, "merging");
+        const merged = mergeInstanceDecisions(id, squadSlug);
+        updateInstanceStatus(id, "done");
+        assert.equal(merged, 0);
+        const completed = getInstance(id);
+        assert.equal(completed.status, "done");
+    });
+    it("sends a notification feed entry on auto-complete", () => {
+        const { id, squadSlug } = setupInstance();
+        const beforeEntries = listFeedEntries({});
+        createFeedEntry({
+            type: "notification",
+            title: `[${squadSlug}] Instance auto-completed`,
+            body: `Instance "${id}" auto-completed after task finished. 0 decision(s) merged to master squad.`,
+            source_type: "instance-auto-complete",
+        });
+        const afterEntries = listFeedEntries({});
+        assert.equal(afterEntries.length, beforeEntries.length + 1);
+        const latest = afterEntries[0];
+        assert.ok(latest.title.includes("auto-completed"));
+        assert.ok(latest.body.includes(id));
+    });
+});
+//# sourceMappingURL=auto-complete-instance.test.js.map