heyio 0.31.0 → 0.32.0

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,6 +12,9 @@ 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";
 // Key format: "squadSlug:characterName" for per-agent sessions, "squadSlug" for legacy
@@ -159,6 +162,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 +301,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");

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

package/dist/copilot/orchestrator.js

@@ -16,6 +16,9 @@ import { delegateToAgent, getActiveAgentTasks, clearAgentInMemorySession } from
 import { saveConfig } from "../config.js";
 import { checkForUpdate } from "../update.js";
 import { startInstanceWatchdog } from "../instance-watchdog.js";
+import { loadMcpConfig } from "../mcp/config.js";
+import { McpConnectionManager } from "../mcp/client.js";
+import { createMcpTools } from "../mcp/registry.js";
 import { createInstance, getInstance, listInstances, updateInstanceStatus, logInstanceDecision, getInstanceDecisions, mergeInstanceDecisions, deleteInstance, buildContextSnapshot, reconcileInstances, ensureInstanceTables, } from "../store/instances.js";
 import { createWorktree, removeWorktree } from "../store/worktrees.js";
 // ---------------------------------------------------------------------------
@@ -141,11 +144,40 @@ function getToolDeps() {
         createWorktree,
         removeWorktree,
         activeInstanceId: undefined,
+        reloadMcpTools: initMcpTools,
     };
 }
+// MCP state — loaded at startup, refreshed on config change
+let mcpToolEntries = [];
+let mcpManager = null;
+export async function initMcpTools() {
+    const config = loadMcpConfig();
+    if (config.servers.length === 0) {
+        mcpToolEntries = [];
+        return;
+    }
+    if (!mcpManager) {
+        mcpManager = new McpConnectionManager();
+    }
+    else {
+        await mcpManager.disconnectAll();
+    }
+    try {
+        mcpToolEntries = await createMcpTools(mcpManager, config);
+        console.error(`[mcp] Loaded ${mcpToolEntries.length} tool(s) from ${config.servers.filter(s => s.enabled !== false).length} server(s)`);
+    }
+    catch (err) {
+        console.error("[mcp] Error loading MCP tools:", err instanceof Error ? err.message : err);
+        mcpToolEntries = [];
+    }
+}
+export function getMcpManager() {
+    return mcpManager;
+}
 function getSessionConfig() {
     const tools = createTools(getToolDeps());
-    return { tools, skillDirectories: getSkillDirectories() };
+    const allTools = [...tools, ...mcpToolEntries.map(e => e.tool)];
+    return { tools: allTools, skillDirectories: getSkillDirectories() };
 }
 /** Hash of tool names + version — used to detect when tools change across updates. */
 function toolFingerprint(tools) {
@@ -431,6 +463,8 @@ export async function initOrchestrator(copilotClient) {
     }
     startInstanceWatchdog();
     clearStaleTasks();
+    // Load MCP server tools
+    await initMcpTools();
     // Validate the configured model and resolve model tiers
     try {
         const models = await copilotClient.listModels();

package/dist/copilot/tools.js

@@ -6,6 +6,7 @@ import { join, dirname, resolve } from "path";
 import { homedir } from "os";
 import { UNIVERSES, getOrCreateUniverse, generateUniverseRoster } from "./universes.js";
 import { createFeedEntry } from "../store/feed.js";
+import { loadMcpConfig, saveMcpConfig } from "../mcp/config.js";
 import { validateCron, nextRun } from "./cron.js";
 import { createIoSchedule, deleteIoSchedule, getIoSchedule, listIoSchedules, setIoScheduleEnabled, updateIoScheduleNextRun, } from "../store/io-schedules.js";
 import { runIoScheduleNow } from "./io-scheduler.js";
@@ -1934,7 +1935,95 @@ export function createTools(deps) {
             return "Notification sent.";
         },
     });
-    return [wikiRead, wikiWrite, wikiSearch, wikiDelete, wikiList, squadCreate, squadRecall, squadStatus, squadLogDecision, squadDelegate, squadTaskStatus, squadDelete, squadAnalyze, squadAddAgent, squadAgents, squadRemoveAgent, squadResetAgent, squadSetLead, squadSetQA, squadTaskReviews, squadScheduleCreate, squadScheduleList, squadScheduleDelete, squadSchedulePause, squadScheduleResume, squadScheduleRunNow, scheduleCreate, scheduleList, scheduleDelete, schedulePause, scheduleResume, scheduleRunNow, skillList, skillInstall, skillRemove, skillSearch, configUpdate, checkUpdate, shell, fileOps, bash, readFile, viewTool, grepTool, strReplaceEditor, github, squadInstanceCreate, squadInstanceList, squadInstanceStatus, squadInstanceComplete, squadInstanceAbort, squadInstanceCleanup, squadInstanceActivate, squadInstanceDeactivate, sendToInbox, sendNotification];
+    const mcpServerList = defineTool("mcp_server_list", {
+        description: "List all configured MCP servers with their status (enabled/disabled, connected/disconnected).",
+        skipPermission: true,
+        parameters: z.object({}),
+        handler: async () => {
+            const config = loadMcpConfig();
+            if (config.servers.length === 0)
+                return "No MCP servers configured. Add one with mcp_server_add.";
+            return config.servers.map(s => {
+                const status = s.enabled === false ? "disabled" : "enabled";
+                const transport = s.url ? `SSE: ${s.url}` : `stdio: ${s.command} ${(s.args ?? []).join(" ")}`;
+                return `- **${s.name}** [${status}] — ${transport}`;
+            }).join("\n");
+        },
+    });
+    const mcpServerAdd = defineTool("mcp_server_add", {
+        description: "Add a new MCP server to the configuration. Provide either command+args (stdio transport) or url (SSE transport).",
+        skipPermission: true,
+        parameters: z.object({
+            name: z.string().describe("Unique name for the server (e.g., 'figma', 'postgres')"),
+            command: z.string().optional().describe("Executable command for stdio transport (e.g., 'npx')"),
+            args: z.array(z.string()).optional().describe("Command arguments (e.g., ['-y', '@anthropic/mcp-server-figma'])"),
+            url: z.string().optional().describe("URL for SSE transport (e.g., 'http://localhost:3001/sse')"),
+            env: z.record(z.string(), z.string()).optional().describe("Environment variables for the server process"),
+        }),
+        handler: async ({ name, command, args, url, env }) => {
+            if (!command && !url)
+                return "Error: provide either 'command' (stdio) or 'url' (SSE).";
+            const config = loadMcpConfig();
+            if (config.servers.some(s => s.name === name)) {
+                return `Error: server "${name}" already exists. Remove it first with mcp_server_remove.`;
+            }
+            config.servers.push({ name, command, args, url, env, enabled: true });
+            saveMcpConfig(config);
+            return `MCP server "${name}" added. Use mcp_server_reload to connect.`;
+        },
+    });
+    const mcpServerRemove = defineTool("mcp_server_remove", {
+        description: "Remove an MCP server from the configuration by name.",
+        skipPermission: true,
+        parameters: z.object({
+            name: z.string().describe("Name of the server to remove"),
+        }),
+        handler: async ({ name }) => {
+            const config = loadMcpConfig();
+            const idx = config.servers.findIndex(s => s.name === name);
+            if (idx === -1)
+                return `Server "${name}" not found.`;
+            config.servers.splice(idx, 1);
+            saveMcpConfig(config);
+            return `MCP server "${name}" removed. Use mcp_server_reload to apply.`;
+        },
+    });
+    const mcpServerToggle = defineTool("mcp_server_toggle", {
+        description: "Enable or disable an MCP server without removing it from the config.",
+        skipPermission: true,
+        parameters: z.object({
+            name: z.string().describe("Name of the server to toggle"),
+            enabled: z.boolean().describe("true to enable, false to disable"),
+        }),
+        handler: async ({ name, enabled }) => {
+            const config = loadMcpConfig();
+            const server = config.servers.find(s => s.name === name);
+            if (!server)
+                return `Server "${name}" not found.`;
+            server.enabled = enabled;
+            saveMcpConfig(config);
+            return `MCP server "${name}" ${enabled ? "enabled" : "disabled"}. Use mcp_server_reload to apply changes.`;
+        },
+    });
+    const mcpServerReload = defineTool("mcp_server_reload", {
+        description: "Reload MCP server connections and tools. Call after adding, removing, or toggling servers to apply changes without restarting IO.",
+        skipPermission: true,
+        parameters: z.object({}),
+        handler: async () => {
+            if (!deps.reloadMcpTools)
+                return "MCP reload not available in this context.";
+            try {
+                await deps.reloadMcpTools();
+                const config = loadMcpConfig();
+                const enabled = config.servers.filter(s => s.enabled !== false);
+                return `MCP tools reloaded. ${enabled.length} server(s) active.`;
+            }
+            catch (err) {
+                return `Error reloading MCP tools: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+    return [wikiRead, wikiWrite, wikiSearch, wikiDelete, wikiList, squadCreate, squadRecall, squadStatus, squadLogDecision, squadDelegate, squadTaskStatus, squadDelete, squadAnalyze, squadAddAgent, squadAgents, squadRemoveAgent, squadResetAgent, squadSetLead, squadSetQA, squadTaskReviews, squadScheduleCreate, squadScheduleList, squadScheduleDelete, squadSchedulePause, squadScheduleResume, squadScheduleRunNow, scheduleCreate, scheduleList, scheduleDelete, schedulePause, scheduleResume, scheduleRunNow, skillList, skillInstall, skillRemove, skillSearch, configUpdate, checkUpdate, shell, fileOps, bash, readFile, viewTool, grepTool, strReplaceEditor, github, squadInstanceCreate, squadInstanceList, squadInstanceStatus, squadInstanceComplete, squadInstanceAbort, squadInstanceCleanup, squadInstanceActivate, squadInstanceDeactivate, sendToInbox, sendNotification, mcpServerList, mcpServerAdd, mcpServerRemove, mcpServerToggle, mcpServerReload];
 }
 function walkDirectory(dir, maxDepth = 3, depth = 0) {
     if (depth >= maxDepth)

package/dist/instance-watchdog.js

@@ -3,23 +3,55 @@
  *
  * Periodically checks for active squad instances that haven't had any
  * task activity beyond a configurable timeout and auto-aborts them.
+ * Also detects instances stuck in 'merging' state (#267).
  */
 import { getDb } from "./store/db.js";
 import { updateInstanceStatus } from "./store/instances.js";
 import { createFeedEntry } from "./store/feed.js";
 const DEFAULT_CHECK_INTERVAL_MS = 5 * 60_000; // Check every 5 minutes
 const DEFAULT_STALE_THRESHOLD_MS = 30 * 60_000; // 30 minutes with no task activity
+const DEFAULT_MERGING_THRESHOLD_MS = 5 * 60_000; // 5 minutes stuck in merging
 /**
- * Find active instances whose last task activity exceeds the threshold.
- * "Activity" is defined as the most recent started_at or completed_at
- * in agent_tasks for that instance, or the instance's created_at if no tasks.
+ * Find instances that are stale or stuck.
+ *
+ * For 'active' instances: uses task-activity-based staleness (last started_at/completed_at).
+ * For 'merging' instances: uses wall-clock since entering merging state (shorter threshold).
  */
-export function findStaleInstances(thresholdMs) {
+export function findStaleInstances(thresholdMs, mergingThresholdMs = DEFAULT_MERGING_THRESHOLD_MS) {
     const db = getDb();
     const now = Date.now();
-    const activeInstances = db.prepare("SELECT * FROM squad_instances WHERE status = 'active'").all();
+    const instances = db.prepare("SELECT * FROM squad_instances WHERE status IN ('active', 'merging')").all();
     const stale = [];
-    for (const instance of activeInstances) {
+    for (const instance of instances) {
+        if (instance.status === "merging") {
+            // Merging instances: use the time they've been in merging state.
+            // We approximate this from completed_at (set when status changes to terminal)
+            // or fall back to created_at. Since updateInstanceStatus doesn't set completed_at
+            // for non-terminal states, we use a query on the DB's internal timestamp approach.
+            // Best proxy: last task completed_at (since merging happens after task completion).
+            const lastTaskCompleted = db.prepare(`
+        SELECT MAX(completed_at) AS last_ts
+        FROM agent_tasks
+        WHERE instance_id = ?
+      `).get(instance.id);
+            const rawTs = lastTaskCompleted?.last_ts ?? instance.created_at;
+            const lastTs = new Date(rawTs.includes("T") ? rawTs : rawTs + "Z").getTime();
+            const idleMs = now - lastTs;
+            if (idleMs >= mergingThresholdMs) {
+                stale.push({ instance, idleMs });
+            }
+            continue;
+        }
+        // Active instances: skip those whose most recent task completed successfully —
+        // auto-complete in agents.ts handles these (#261)
+        const latestTaskStatus = db.prepare(`
+      SELECT status FROM agent_tasks
+      WHERE instance_id = ?
+      ORDER BY COALESCE(completed_at, started_at) DESC
+      LIMIT 1
+    `).get(instance.id);
+        if (latestTaskStatus?.status === "done")
+            continue;
         // Find the most recent task activity for this instance
         const lastActivity = db.prepare(`
       SELECT MAX(COALESCE(completed_at, started_at)) AS last_ts
@@ -41,16 +73,18 @@ export function findStaleInstances(thresholdMs) {
 export function startInstanceWatchdog(opts = {}) {
     const checkInterval = opts.checkIntervalMs ?? DEFAULT_CHECK_INTERVAL_MS;
     const staleThreshold = opts.staleThresholdMs ?? DEFAULT_STALE_THRESHOLD_MS;
+    const mergingThreshold = opts.mergingThresholdMs ?? DEFAULT_MERGING_THRESHOLD_MS;
     const timer = setInterval(() => {
         try {
-            const staleInstances = findStaleInstances(staleThreshold);
+            const staleInstances = findStaleInstances(staleThreshold, mergingThreshold);
             for (const { instance, idleMs } of staleInstances) {
-                console.error(`[instance-watchdog] Auto-aborting stale instance "${instance.id}" — idle for ${Math.round(idleMs / 60_000)}m (threshold: ${Math.round(staleThreshold / 60_000)}m)`);
+                const reason = instance.status === "merging" ? "stuck in merging" : "idle";
+                console.error(`[instance-watchdog] Auto-aborting ${reason} instance "${instance.id}" — ${Math.round(idleMs / 60_000)}m (threshold: ${Math.round(instance.status === "merging" ? mergingThreshold / 60_000 : staleThreshold / 60_000)}m)`);
                 updateInstanceStatus(instance.id, "failed");
                 createFeedEntry({
                     type: "notification",
                     title: `[${instance.master_squad_slug}] Instance auto-aborted`,
-                    body: `Instance "${instance.id}" was auto-aborted after ${Math.round(idleMs / 60_000)} minutes of inactivity. Worktree preserved at: ${instance.worktree_path}`,
+                    body: `Instance "${instance.id}" was auto-aborted (${reason}) after ${Math.round(idleMs / 60_000)} minutes. Worktree preserved at: ${instance.worktree_path}`,
                     source_type: "instance-watchdog",
                 });
                 if (opts.onAbort) {