heyio 0.28.0 → 0.30.0

package/dist/api/server.js

@@ -4,7 +4,9 @@ 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 { listSquads, createSquad, listSquadAgents } from "../store/squads.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";
 import { getAgentInfo, cancelAgentTask, getTaskEvents, subscribeToTaskEvents } from "../copilot/agents.js";
 import { summarize, summarizeEvent } from "../copilot/event-summary.js";
 import { abortOrchestrator } from "../copilot/orchestrator.js";
@@ -453,6 +455,122 @@ export async function startApiServer() {
             res.status(500).json({ error: "Failed to list squad agents" });
         }
     });
+    // Squad Instances
+    api.get("/squads/:slug/instances", (req, res) => {
+        try {
+            const slug = Array.isArray(req.params.slug) ? req.params.slug[0] : req.params.slug;
+            const includeCompleted = req.query.include_completed === "true";
+            const instances = listInstances(slug, { includeCompleted });
+            res.json({ instances });
+        }
+        catch (e) {
+            console.error("Error listing instances:", e);
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    api.post("/squads/:slug/instances", (req, res) => {
+        try {
+            const slug = Array.isArray(req.params.slug) ? req.params.slug[0] : req.params.slug;
+            const { issue_ref, base_branch } = req.body;
+            const squad = getSquad(slug);
+            if (!squad) {
+                res.status(404).json({ error: "Squad not found" });
+                return;
+            }
+            const sanitizedRef = (issue_ref ?? "task").replace(/[^a-zA-Z0-9_-]/g, "-").toLowerCase();
+            const instanceId = `${slug}--${sanitizedRef}`;
+            const branchName = `${slug}/instance/${sanitizedRef}`;
+            const contextSnapshot = buildContextSnapshot(slug);
+            const worktreePath = createWorktree(squad.project_path, instanceId, branchName, base_branch ?? "main");
+            let instance;
+            try {
+                instance = createInstance({
+                    id: instanceId,
+                    masterSquadSlug: slug,
+                    issueRef: issue_ref,
+                    worktreePath,
+                    branchName,
+                    contextSnapshot,
+                });
+            }
+            catch (createErr) {
+                // Roll back the worktree if DB insert fails (e.g. max instances exceeded)
+                removeWorktree(squad.project_path, worktreePath);
+                throw createErr;
+            }
+            updateInstanceStatus(instanceId, "active");
+            res.status(201).json({ instance: { ...instance, status: "active" } });
+        }
+        catch (e) {
+            console.error("Error creating instance:", e);
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    api.get("/squads/:slug/instances/:id", (req, res) => {
+        try {
+            const slug = Array.isArray(req.params.slug) ? req.params.slug[0] : req.params.slug;
+            const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+            const instance = getInstance(id);
+            if (!instance || instance.master_squad_slug !== slug) {
+                res.status(404).json({ error: "Instance not found" });
+                return;
+            }
+            const decisions = getInstanceDecisions(id);
+            res.json({ instance, decisions });
+        }
+        catch (e) {
+            console.error("Error getting instance:", e);
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    api.post("/squads/:slug/instances/:id/complete", (req, res) => {
+        try {
+            const slug = Array.isArray(req.params.slug) ? req.params.slug[0] : req.params.slug;
+            const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+            const instance = getInstance(id);
+            if (!instance || instance.master_squad_slug !== slug) {
+                res.status(404).json({ error: "Instance not found" });
+                return;
+            }
+            if (instance.status === "done") {
+                res.json({ message: "Already completed", merged: 0 });
+                return;
+            }
+            updateInstanceStatus(id, "merging");
+            const merged = mergeInstanceDecisions(id, instance.master_squad_slug);
+            const squad = getSquad(instance.master_squad_slug);
+            if (squad) {
+                removeWorktree(squad.project_path, instance.worktree_path);
+            }
+            updateInstanceStatus(id, "done");
+            res.json({ message: "Instance completed", merged });
+        }
+        catch (e) {
+            console.error("Error completing instance:", e);
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    api.post("/squads/:slug/instances/:id/abort", (req, res) => {
+        try {
+            const slug = Array.isArray(req.params.slug) ? req.params.slug[0] : req.params.slug;
+            const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+            const instance = getInstance(id);
+            if (!instance || instance.master_squad_slug !== slug) {
+                res.status(404).json({ error: "Instance not found" });
+                return;
+            }
+            if (instance.status === "done" || instance.status === "failed") {
+                res.json({ message: `Already in terminal state: ${instance.status}` });
+                return;
+            }
+            updateInstanceStatus(id, "failed");
+            res.json({ message: "Instance aborted", worktree_path: instance.worktree_path });
+        }
+        catch (e) {
+            console.error("Error aborting instance:", e);
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
     // Agents endpoints
     api.get("/agents", (_req, res) => {
         try {

package/dist/copilot/agents.js

@@ -159,7 +159,7 @@ ${task}
 
 ${tail}`;
 }
-export async function delegateToAgent(squadSlug, task, onComplete, targetAgent) {
+export async function delegateToAgent(squadSlug, task, onComplete, targetAgent, instanceId) {
     const squad = getSquad(squadSlug);
     if (!squad) {
         throw new Error(`Squad not found: ${squadSlug}`);
@@ -206,7 +206,7 @@ export async function delegateToAgent(squadSlug, task, onComplete, targetAgent)
         ? await getOrCreateAgentSession(squadSlug, agent, task)
         : await getOrCreateSession(squadSlug, task);
     const taskId = randomUUID();
-    createTask(taskId, agentKey, task);
+    createTask(taskId, agentKey, task, undefined, instanceId);
     updateSquadStatus(squadSlug, "working");
     if (agent)
         updateAgentStatus(squadSlug, agent.character_name, "working");

package/dist/copilot/orchestrator.js

@@ -15,6 +15,9 @@ import { resetClient } from "./client.js";
 import { delegateToAgent, getActiveAgentTasks, clearAgentInMemorySession } from "./agents.js";
 import { saveConfig } from "../config.js";
 import { checkForUpdate } from "../update.js";
+import { startInstanceWatchdog } from "../instance-watchdog.js";
+import { createInstance, getInstance, listInstances, updateInstanceStatus, logInstanceDecision, getInstanceDecisions, mergeInstanceDecisions, deleteInstance, buildContextSnapshot, reconcileInstances, ensureInstanceTables, } from "../store/instances.js";
+import { createWorktree, removeWorktree } from "../store/worktrees.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -62,7 +65,7 @@ function getToolDeps() {
             created_at: d.created_at,
         })),
         updateSquadStatus,
-        delegateToAgent,
+        delegateToAgent: (squadSlug, task, onComplete, targetAgent, instanceId) => delegateToAgent(squadSlug, task, onComplete, targetAgent, instanceId),
         getTask,
         getActiveAgentTasks: () => getActiveAgentTasks().map((t) => ({
             taskId: t.taskId,
@@ -124,6 +127,20 @@ function getToolDeps() {
         searchSkillsRegistry,
         saveConfig,
         checkForUpdate,
+        // Squad instance deps
+        createInstance,
+        getInstance,
+        listInstances,
+        updateInstanceStatus,
+        logInstanceDecision,
+        getInstanceDecisions,
+        mergeInstanceDecisions,
+        deleteInstance,
+        buildContextSnapshot,
+        reconcileInstances,
+        createWorktree,
+        removeWorktree,
+        activeInstanceId: undefined,
     };
 }
 function getSessionConfig() {
@@ -407,6 +424,12 @@ async function processQueue() {
 // ---------------------------------------------------------------------------
 export async function initOrchestrator(copilotClient) {
     client = copilotClient;
+    ensureInstanceTables();
+    const reconciledInstances = reconcileInstances();
+    if (reconciledInstances > 0) {
+        console.error(`[orchestrator] Reconciled ${reconciledInstances} stale instance(s) on startup`);
+    }
+    startInstanceWatchdog();
     clearStaleTasks();
     // Validate the configured model and resolve model tiers
     try {

package/dist/copilot/tools.js

@@ -373,6 +373,11 @@ export function createTools(deps) {
         }),
         handler: async ({ slug, decision, context }) => {
             try {
+                // If we're in an instance context, route to instance decisions
+                if (deps.activeInstanceId) {
+                    deps.logInstanceDecision(deps.activeInstanceId, decision, context);
+                    return `Decision logged for instance ${deps.activeInstanceId} (squad ${slug})`;
+                }
                 deps.logDecision(slug, decision, context);
                 return `Decision logged for squad ${slug}`;
             }
@@ -405,7 +410,7 @@ export function createTools(deps) {
                         createFeedEntry({ type: "deliverable", title: `[${slug}] Task result`, body: result });
                         console.error(`[io] Task ${id} result routed to inbox`);
                     }
-                }, agent);
+                }, agent, deps.activeInstanceId);
                 const agentLabel = agent ? `agent "${agent}" in squad "${slug}"` : `squad "${slug}"`;
                 const warningPrefix = coverage.warning
                     ? `${coverage.warning} A dedicated lead and a QA reviewer should both hold veto power on PR promotion — fix gaps before promoting work.\n\n`
@@ -1704,7 +1709,183 @@ export function createTools(deps) {
             return `🚀 Fired IO schedule ${id} now.`;
         },
     });
-    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];
+    // ---------------------------------------------------------------------------
+    // Squad Instance tools (#231)
+    // ---------------------------------------------------------------------------
+    const squadInstanceCreate = defineTool("squad_instance_create", {
+        description: "Spawn a parallel instance of a squad to work on a separate issue. Creates a git worktree for file isolation and snapshots the squad's current decisions as context.",
+        skipPermission: true,
+        parameters: z.object({
+            squad_slug: z.string().describe("The squad to create an instance of"),
+            issue_ref: z.string().describe("Issue reference or label (e.g. '#231', 'refactor-auth')"),
+            base_branch: z.string().optional().describe("Branch to base the worktree on (default: 'main')"),
+        }),
+        handler: async ({ squad_slug, issue_ref, base_branch }) => {
+            const squad = deps.getSquad(squad_slug);
+            if (!squad)
+                return `Squad not found: ${squad_slug}`;
+            // Deterministic ID: allows idempotent re-creation if an instance for
+            // the same issue_ref previously completed or failed.
+            const sanitizedRef = issue_ref.replace(/[^a-zA-Z0-9_-]/g, "-").toLowerCase();
+            const instanceId = `${squad_slug}--${sanitizedRef}`;
+            const branchName = `${squad_slug}/instance/${sanitizedRef}`;
+            const existing = deps.getInstance(instanceId);
+            if (existing && existing.status !== "done" && existing.status !== "failed") {
+                return `Instance "${instanceId}" already exists (status: ${existing.status})`;
+            }
+            try {
+                const contextSnapshot = deps.buildContextSnapshot(squad_slug);
+                const worktreePath = deps.createWorktree(squad.projectPath, instanceId, branchName, base_branch ?? "main");
+                deps.createInstance({
+                    id: instanceId,
+                    masterSquadSlug: squad_slug,
+                    issueRef: issue_ref,
+                    worktreePath,
+                    branchName,
+                    contextSnapshot,
+                });
+                deps.updateInstanceStatus(instanceId, "active");
+                const inherited = JSON.parse(contextSnapshot);
+                return `Instance "${instanceId}" created.\nWorktree: ${worktreePath}\nBranch: ${branchName}\nStatus: active\nContext: ${inherited.length} decisions inherited`;
+            }
+            catch (err) {
+                return `Error creating instance: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+    const squadInstanceList = defineTool("squad_instance_list", {
+        description: "List active (and optionally completed) instances for a squad.",
+        skipPermission: true,
+        parameters: z.object({
+            squad_slug: z.string().describe("Squad slug"),
+            include_completed: z.boolean().optional().describe("Include done/failed instances (default: false)"),
+        }),
+        handler: async ({ squad_slug, include_completed }) => {
+            const instances = deps.listInstances(squad_slug, { includeCompleted: include_completed ?? false });
+            if (instances.length === 0)
+                return `No instances for squad "${squad_slug}".`;
+            return instances.map(i => `- **${i.id}** [${i.status}] — ${i.issue_ref ?? "no issue"} (branch: ${i.branch_name}, created: ${i.created_at})`).join("\n");
+        },
+    });
+    const squadInstanceStatus = defineTool("squad_instance_status", {
+        description: "Get detailed status of a specific squad instance.",
+        skipPermission: true,
+        parameters: z.object({
+            instance_id: z.string().describe("Instance ID (e.g. 'my-squad--issue-42')"),
+        }),
+        handler: async ({ instance_id }) => {
+            const instance = deps.getInstance(instance_id);
+            if (!instance)
+                return `Instance not found: ${instance_id}`;
+            const decisions = deps.getInstanceDecisions(instance_id);
+            return [
+                `## Instance: ${instance.id}`,
+                `- Squad: ${instance.master_squad_slug}`,
+                `- Issue: ${instance.issue_ref ?? "none"}`,
+                `- Status: ${instance.status}`,
+                `- Branch: ${instance.branch_name}`,
+                `- Worktree: ${instance.worktree_path}`,
+                `- Created: ${instance.created_at}`,
+                instance.completed_at ? `- Completed: ${instance.completed_at}` : null,
+                `- Decisions: ${decisions.length} (${decisions.filter(d => d.merged_to_master).length} merged)`,
+            ].filter(Boolean).join("\n");
+        },
+    });
+    const squadInstanceComplete = defineTool("squad_instance_complete", {
+        description: "Complete a squad instance: merge its decisions back to the master squad and clean up the worktree.",
+        skipPermission: true,
+        parameters: z.object({
+            instance_id: z.string().describe("Instance ID to complete"),
+        }),
+        handler: async ({ instance_id }) => {
+            const instance = deps.getInstance(instance_id);
+            if (!instance)
+                return `Instance not found: ${instance_id}`;
+            if (instance.status === "done")
+                return `Instance already completed.`;
+            try {
+                deps.updateInstanceStatus(instance_id, "merging");
+                const merged = deps.mergeInstanceDecisions(instance_id, instance.master_squad_slug);
+                // Clean up worktree — use squad's project_path if available, fall back to stored path
+                const squad = deps.getSquad(instance.master_squad_slug);
+                const projectPath = squad?.projectPath ?? instance.worktree_path.replace(/\/\.io-worktrees\/.*$/, "");
+                deps.removeWorktree(projectPath, instance.worktree_path);
+                deps.updateInstanceStatus(instance_id, "done");
+                return `Instance "${instance_id}" completed.\n- ${merged} decision(s) merged to master squad "${instance.master_squad_slug}"\n- Worktree cleaned up`;
+            }
+            catch (err) {
+                return `Error completing instance: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+    const squadInstanceAbort = defineTool("squad_instance_abort", {
+        description: "Abort a squad instance, marking it as failed. Worktree is preserved for debugging.",
+        skipPermission: true,
+        parameters: z.object({
+            instance_id: z.string().describe("Instance ID to abort"),
+        }),
+        handler: async ({ instance_id }) => {
+            const instance = deps.getInstance(instance_id);
+            if (!instance)
+                return `Instance not found: ${instance_id}`;
+            if (instance.status === "done" || instance.status === "failed") {
+                return `Instance already in terminal state: ${instance.status}`;
+            }
+            deps.updateInstanceStatus(instance_id, "failed");
+            return `Instance "${instance_id}" aborted. Worktree preserved at: ${instance.worktree_path}\nUse squad_instance_cleanup to remove it.`;
+        },
+    });
+    const squadInstanceCleanup = defineTool("squad_instance_cleanup", {
+        description: "Force-remove a failed instance's worktree and delete the instance record.",
+        skipPermission: true,
+        parameters: z.object({
+            instance_id: z.string().describe("Instance ID to clean up"),
+        }),
+        handler: async ({ instance_id }) => {
+            const instance = deps.getInstance(instance_id);
+            if (!instance)
+                return `Instance not found: ${instance_id}`;
+            if (instance.status !== "done" && instance.status !== "failed") {
+                return `Cannot clean up instance in "${instance.status}" state. Abort it first.`;
+            }
+            const squad = deps.getSquad(instance.master_squad_slug);
+            if (squad) {
+                deps.removeWorktree(squad.projectPath, instance.worktree_path);
+            }
+            deps.deleteInstance(instance_id);
+            return `Instance "${instance_id}" cleaned up and removed.`;
+        },
+    });
+    // ---------------------------------------------------------------------------
+    // Squad Instance context tools (#231 Phase 2)
+    // ---------------------------------------------------------------------------
+    const squadInstanceActivate = defineTool("squad_instance_activate", {
+        description: "Activate an instance context. After activation, delegated tasks and decisions are scoped to this instance until deactivated.",
+        skipPermission: true,
+        parameters: z.object({
+            instance_id: z.string().describe("Instance ID to activate"),
+        }),
+        handler: async ({ instance_id }) => {
+            const instance = deps.getInstance(instance_id);
+            if (!instance)
+                return `Instance not found: ${instance_id}`;
+            if (instance.status !== "active")
+                return `Instance is not active (status: ${instance.status})`;
+            deps.activeInstanceId = instance_id;
+            return `Instance context activated: ${instance_id}. Tasks and decisions will be scoped to this instance.`;
+        },
+    });
+    const squadInstanceDeactivate = defineTool("squad_instance_deactivate", {
+        description: "Deactivate the current instance context, returning to master squad scope.",
+        skipPermission: true,
+        parameters: z.object({}),
+        handler: async () => {
+            const prev = deps.activeInstanceId;
+            deps.activeInstanceId = undefined;
+            return prev ? `Instance context deactivated (was: ${prev})` : `No instance context was active.`;
+        },
+    });
+    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];
 }
 function walkDirectory(dir, maxDepth = 3, depth = 0) {
     if (depth >= maxDepth)

package/dist/instance-watchdog.js

@@ -0,0 +1,70 @@
+/**
+ * Instance liveness watchdog.
+ *
+ * Periodically checks for active squad instances that haven't had any
+ * task activity beyond a configurable timeout and auto-aborts them.
+ */
+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
+/**
+ * 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.
+ */
+export function findStaleInstances(thresholdMs) {
+    const db = getDb();
+    const now = Date.now();
+    const activeInstances = db.prepare("SELECT * FROM squad_instances WHERE status = 'active'").all();
+    const stale = [];
+    for (const instance of activeInstances) {
+        // Find the most recent task activity for this instance
+        const lastActivity = db.prepare(`
+      SELECT MAX(COALESCE(completed_at, started_at)) AS last_ts
+      FROM agent_tasks
+      WHERE instance_id = ?
+    `).get(instance.id);
+        const rawTs = lastActivity?.last_ts ?? instance.created_at;
+        const lastTs = new Date(rawTs.includes("T") ? rawTs : rawTs + "Z").getTime();
+        const idleMs = now - lastTs;
+        if (idleMs >= thresholdMs) {
+            stale.push({ instance, idleMs });
+        }
+    }
+    return stale;
+}
+/**
+ * Start the instance watchdog. Returns a stop function.
+ */
+export function startInstanceWatchdog(opts = {}) {
+    const checkInterval = opts.checkIntervalMs ?? DEFAULT_CHECK_INTERVAL_MS;
+    const staleThreshold = opts.staleThresholdMs ?? DEFAULT_STALE_THRESHOLD_MS;
+    const timer = setInterval(() => {
+        try {
+            const staleInstances = findStaleInstances(staleThreshold);
+            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)`);
+                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}`,
+                    source_type: "instance-watchdog",
+                });
+                if (opts.onAbort) {
+                    opts.onAbort(instance, idleMs);
+                }
+            }
+        }
+        catch (err) {
+            console.error("[instance-watchdog] Error during check:", err);
+        }
+    }, checkInterval);
+    timer.unref();
+    return () => {
+        clearInterval(timer);
+    };
+}
+//# sourceMappingURL=instance-watchdog.js.map

package/dist/instance-watchdog.test.js

@@ -0,0 +1,112 @@
+import { before, after, beforeEach, describe, it } 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 { setDbPathForTests, closeDb, getDb } from "./store/db.js";
+import { ensureInstanceTables } from "./store/instances.js";
+import { findStaleInstances, startInstanceWatchdog } from "./instance-watchdog.js";
+let tmpDir;
+before(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "io-inst-watchdog-test-"));
+    setDbPathForTests(join(tmpDir, "io.db"));
+    ensureInstanceTables();
+});
+after(() => {
+    closeDb();
+    rmSync(tmpDir, { recursive: true, force: true });
+});
+beforeEach(() => {
+    const db = getDb();
+    db.prepare("DELETE FROM agent_tasks").run();
+    db.prepare("DELETE FROM squad_instances").run();
+    db.prepare("DELETE FROM squads").run();
+    db.prepare("INSERT INTO squads (slug, name, project_path) VALUES (?, ?, ?)").run("test-squad", "Test", "/tmp/test");
+});
+describe("instance watchdog", () => {
+    describe("findStaleInstances", () => {
+        it("detects stale active instances with no task activity", () => {
+            const db = getDb();
+            db.prepare(`
+        INSERT INTO squad_instances (id, master_squad_slug, worktree_path, branch_name, status, created_at)
+        VALUES (?, ?, ?, ?, 'active', datetime('now', '-60 minutes'))
+      `).run("test-squad--old", "test-squad", "/tmp/wt", "test-squad/instance/old");
+            const stale = findStaleInstances(30 * 60_000);
+            assert.strictEqual(stale.length, 1);
+            assert.strictEqual(stale[0].instance.id, "test-squad--old");
+        });
+        it("does not flag instances with recent task activity", () => {
+            const db = getDb();
+            db.prepare(`
+        INSERT INTO squad_instances (id, master_squad_slug, worktree_path, branch_name, status, created_at)
+        VALUES (?, ?, ?, ?, 'active', datetime('now', '-60 minutes'))
+      `).run("test-squad--recent", "test-squad", "/tmp/wt2", "test-squad/instance/recent");
+            db.prepare(`
+        INSERT INTO agent_tasks (task_id, agent_slug, description, instance_id, started_at)
+        VALUES (?, ?, ?, ?, datetime('now', '-5 minutes'))
+      `).run("task-recent", "agent-1", "Work", "test-squad--recent");
+            const stale = findStaleInstances(30 * 60_000);
+            assert.strictEqual(stale.length, 0);
+        });
+        it("does not flag non-active instances", () => {
+            const db = getDb();
+            db.prepare(`
+        INSERT INTO squad_instances (id, master_squad_slug, worktree_path, branch_name, status, created_at)
+        VALUES (?, ?, ?, ?, 'done', datetime('now', '-120 minutes'))
+      `).run("test-squad--done", "test-squad", "/tmp/wt3", "test-squad/instance/done");
+            const stale = findStaleInstances(30 * 60_000);
+            assert.strictEqual(stale.length, 0);
+        });
+        it("calculates idleMs correctly relative to now", () => {
+            const db = getDb();
+            db.prepare(`
+        INSERT INTO squad_instances (id, master_squad_slug, worktree_path, branch_name, status, created_at)
+        VALUES (?, ?, ?, ?, 'active', datetime('now', '-45 minutes'))
+      `).run("test-squad--mid", "test-squad", "/tmp/wt4", "test-squad/instance/mid");
+            const stale = findStaleInstances(30 * 60_000);
+            assert.strictEqual(stale.length, 1);
+            assert.ok(stale[0].idleMs >= 44 * 60_000);
+            assert.ok(stale[0].idleMs <= 46 * 60_000);
+        });
+    });
+    describe("startInstanceWatchdog", () => {
+        it("calls onAbort for stale instances and stops cleanly", async () => {
+            const db = getDb();
+            db.prepare(`
+        INSERT INTO squad_instances (id, master_squad_slug, worktree_path, branch_name, status, created_at)
+        VALUES (?, ?, ?, ?, 'active', datetime('now', '-60 minutes'))
+      `).run("test-squad--stale", "test-squad", "/tmp/wt5", "test-squad/instance/stale");
+            const aborted = [];
+            const stop = startInstanceWatchdog({
+                checkIntervalMs: 50,
+                staleThresholdMs: 30 * 60_000,
+                onAbort: (inst) => aborted.push(inst.id),
+            });
+            // Wait for at least one interval to fire
+            await new Promise((r) => setTimeout(r, 150));
+            stop();
+            assert.ok(aborted.includes("test-squad--stale"));
+            // Verify it was marked failed
+            const row = db.prepare("SELECT status FROM squad_instances WHERE id = ?").get("test-squad--stale");
+            assert.strictEqual(row.status, "failed");
+        });
+        it("stop function prevents further checks", async () => {
+            const db = getDb();
+            db.prepare(`
+        INSERT INTO squad_instances (id, master_squad_slug, worktree_path, branch_name, status, created_at)
+        VALUES (?, ?, ?, ?, 'active', datetime('now', '-60 minutes'))
+      `).run("test-squad--late", "test-squad", "/tmp/wt6", "test-squad/instance/late");
+            let abortCount = 0;
+            const stop = startInstanceWatchdog({
+                checkIntervalMs: 50,
+                staleThresholdMs: 30 * 60_000,
+                onAbort: () => abortCount++,
+            });
+            stop(); // Stop immediately before any tick fires
+            await new Promise((r) => setTimeout(r, 150));
+            // Instance should NOT have been aborted since we stopped before first tick
+            assert.strictEqual(abortCount, 0);
+        });
+    });
+});
+//# sourceMappingURL=instance-watchdog.test.js.map

package/dist/store/db.js

@@ -172,6 +172,27 @@ GROUP BY agent_slug`,
     )`,
         `CREATE INDEX IF NOT EXISTS idx_unified_feed_type ON unified_feed(type, created_at)`,
         `CREATE INDEX IF NOT EXISTS idx_unified_feed_unread ON unified_feed(read_at, created_at)`,
+        `CREATE TABLE IF NOT EXISTS squad_instances (
+      id TEXT PRIMARY KEY,
+      master_squad_slug TEXT NOT NULL,
+      issue_ref TEXT,
+      worktree_path TEXT NOT NULL,
+      branch_name TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending',
+      context_snapshot TEXT,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      completed_at DATETIME
+    )`,
+        `CREATE TABLE IF NOT EXISTS instance_decisions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      instance_id TEXT NOT NULL,
+      decision TEXT NOT NULL,
+      context TEXT,
+      merged_to_master INTEGER DEFAULT 0,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )`,
+        `ALTER TABLE agent_tasks ADD COLUMN instance_id TEXT`,
+        `CREATE INDEX IF NOT EXISTS idx_instance_decisions_instance ON instance_decisions(instance_id, merged_to_master)`,
     ];
     for (const migration of migrations) {
         try {