heyio 0.29.0 → 0.30.0

package/dist/store/instances.js

@@ -0,0 +1,131 @@
+import { getDb } from "./db.js";
+import { getDecisions } from "./squads.js";
+import { worktreeExists } from "./worktrees.js";
+export function ensureInstanceTables() {
+    const db = getDb();
+    db.exec(`
+    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
+    );
+  `);
+}
+export const MAX_CONCURRENT_INSTANCES = 3;
+export function createInstance(input) {
+    const db = getDb();
+    const activeCount = db
+        .prepare("SELECT COUNT(*) as cnt FROM squad_instances WHERE master_squad_slug = ? AND status NOT IN ('done', 'failed')")
+        .get(input.masterSquadSlug).cnt;
+    if (activeCount >= MAX_CONCURRENT_INSTANCES) {
+        throw new Error(`Max concurrent instances (${MAX_CONCURRENT_INSTANCES}) reached for squad "${input.masterSquadSlug}"`);
+    }
+    db.prepare(`INSERT INTO squad_instances (id, master_squad_slug, issue_ref, worktree_path, branch_name, status, context_snapshot)
+     VALUES (?, ?, ?, ?, ?, 'pending', ?)`).run(input.id, input.masterSquadSlug, input.issueRef ?? null, input.worktreePath, input.branchName, input.contextSnapshot ?? null);
+    return getInstance(input.id);
+}
+export function getInstance(id) {
+    const db = getDb();
+    return db.prepare("SELECT * FROM squad_instances WHERE id = ?").get(id);
+}
+export function listInstances(masterSquadSlug, opts) {
+    const db = getDb();
+    const includeCompleted = opts?.includeCompleted ?? false;
+    if (includeCompleted) {
+        return db
+            .prepare("SELECT id, issue_ref, status, branch_name, created_at, completed_at FROM squad_instances WHERE master_squad_slug = ? ORDER BY created_at DESC")
+            .all(masterSquadSlug);
+    }
+    return db
+        .prepare("SELECT id, issue_ref, status, branch_name, created_at, completed_at FROM squad_instances WHERE master_squad_slug = ? AND status NOT IN ('done', 'failed') ORDER BY created_at DESC")
+        .all(masterSquadSlug);
+}
+export function updateInstanceStatus(id, status) {
+    const db = getDb();
+    if (status === "done" || status === "failed") {
+        db.prepare("UPDATE squad_instances SET status = ?, completed_at = CURRENT_TIMESTAMP WHERE id = ?").run(status, id);
+    }
+    else {
+        db.prepare("UPDATE squad_instances SET status = ? WHERE id = ?").run(status, id);
+    }
+}
+export function logInstanceDecision(instanceId, decision, context) {
+    const db = getDb();
+    db.prepare("INSERT INTO instance_decisions (instance_id, decision, context) VALUES (?, ?, ?)").run(instanceId, decision, context ?? null);
+}
+export function getInstanceDecisions(instanceId) {
+    const db = getDb();
+    return db
+        .prepare("SELECT decision, context, created_at, merged_to_master FROM instance_decisions WHERE instance_id = ? ORDER BY created_at ASC")
+        .all(instanceId);
+}
+/**
+ * Merge instance decisions back to master squad. Returns count merged.
+ */
+export function mergeInstanceDecisions(instanceId, masterSquadSlug) {
+    const db = getDb();
+    const decisions = db
+        .prepare("SELECT id, decision, context FROM instance_decisions WHERE instance_id = ? AND merged_to_master = 0")
+        .all(instanceId);
+    if (decisions.length === 0)
+        return 0;
+    const insertStmt = db.prepare("INSERT INTO squad_decisions (squad_slug, decision, context) VALUES (?, ?, ?)");
+    const markStmt = db.prepare("UPDATE instance_decisions SET merged_to_master = 1 WHERE id = ?");
+    const mergeAll = db.transaction(() => {
+        for (const d of decisions) {
+            const ctx = d.context
+                ? `${d.context} [from instance: ${instanceId}]`
+                : `[from instance: ${instanceId}]`;
+            insertStmt.run(masterSquadSlug, d.decision, ctx);
+            markStmt.run(d.id);
+        }
+    });
+    mergeAll();
+    return decisions.length;
+}
+export function deleteInstance(id) {
+    const db = getDb();
+    db.prepare("DELETE FROM instance_decisions WHERE instance_id = ?").run(id);
+    db.prepare("DELETE FROM squad_instances WHERE id = ?").run(id);
+}
+/**
+ * Build a JSON snapshot of the master squad's recent decisions for context inheritance.
+ */
+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 })));
+}
+/**
+ * Reconcile instances on startup: detect orphaned worktrees and mark stale active instances.
+ * Returns the number of instances cleaned up.
+ */
+export function reconcileInstances() {
+    const db = getDb();
+    const activeInstances = db
+        .prepare("SELECT id, worktree_path FROM squad_instances WHERE status IN ('active', 'pending', 'merging')")
+        .all();
+    let cleaned = 0;
+    for (const inst of activeInstances) {
+        if (!worktreeExists(inst.worktree_path)) {
+            updateInstanceStatus(inst.id, "failed");
+            cleaned++;
+        }
+    }
+    return cleaned;
+}
+//# sourceMappingURL=instances.js.map

package/dist/store/instances.test.js

@@ -0,0 +1,291 @@
+/**
+ * Tests for src/store/instances.ts — squad instances store.
+ *
+ * DB isolation: setDbPathForTests() redirects the SQLite singleton to a
+ * fresh tmp file so these tests never touch ~/.io/io.db.
+ */
+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 "./db.js";
+import { createInstance, getInstance, listInstances, updateInstanceStatus, logInstanceDecision, getInstanceDecisions, mergeInstanceDecisions, deleteInstance, buildContextSnapshot, reconcileInstances, MAX_CONCURRENT_INSTANCES, } from "./instances.js";
+import { logDecision, getDecisions } from "./squads.js";
+// ── DB isolation ─────────────────────────────────────────────────────────────
+let tmpDir;
+before(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "io-instances-test-"));
+    setDbPathForTests(join(tmpDir, "io.db"));
+});
+after(() => {
+    closeDb();
+    rmSync(tmpDir, { recursive: true, force: true });
+});
+beforeEach(() => {
+    const db = getDb();
+    db.prepare("DELETE FROM instance_decisions").run();
+    db.prepare("DELETE FROM squad_instances").run();
+    db.prepare("DELETE FROM squad_decisions").run();
+    db.prepare("DELETE FROM squads").run();
+    db.prepare("INSERT INTO squads (slug, name, project_path) VALUES (?, ?, ?)").run("test-squad", "Test Squad", "/tmp/test");
+});
+// ── helpers ───────────────────────────────────────────────────────────────────
+function makeInstance(id, slug = "test-squad", status) {
+    const inst = createInstance({
+        id,
+        masterSquadSlug: slug,
+        issueRef: `#${id}`,
+        worktreePath: `/tmp/nonexistent-worktree-${id}`,
+        branchName: `${slug}/instance/${id}`,
+    });
+    if (status && status !== "pending") {
+        updateInstanceStatus(id, status);
+    }
+    return inst;
+}
+// ── createInstance ────────────────────────────────────────────────────────────
+describe("createInstance", () => {
+    it("creates and returns an instance with correct fields", () => {
+        const inst = createInstance({
+            id: "inst-1",
+            masterSquadSlug: "test-squad",
+            issueRef: "#42",
+            worktreePath: "/tmp/wt/inst-1",
+            branchName: "test-squad/instance/inst-1",
+            contextSnapshot: JSON.stringify([{ decision: "use TypeScript" }]),
+        });
+        assert.equal(inst.id, "inst-1");
+        assert.equal(inst.master_squad_slug, "test-squad");
+        assert.equal(inst.issue_ref, "#42");
+        assert.equal(inst.worktree_path, "/tmp/wt/inst-1");
+        assert.equal(inst.branch_name, "test-squad/instance/inst-1");
+        assert.equal(inst.status, "pending");
+        assert.ok(inst.context_snapshot?.includes("use TypeScript"));
+        assert.equal(inst.completed_at, null);
+        assert.ok(inst.created_at);
+    });
+    it("throws when max concurrent instances are exceeded", () => {
+        // Create MAX_CONCURRENT_INSTANCES active instances
+        for (let i = 1; i <= MAX_CONCURRENT_INSTANCES; i++) {
+            createInstance({
+                id: `inst-max-${i}`,
+                masterSquadSlug: "test-squad",
+                worktreePath: `/tmp/wt/inst-max-${i}`,
+                branchName: `test-squad/instance/inst-max-${i}`,
+            });
+        }
+        assert.throws(() => createInstance({
+            id: "inst-over-limit",
+            masterSquadSlug: "test-squad",
+            worktreePath: "/tmp/wt/inst-over-limit",
+            branchName: "test-squad/instance/inst-over-limit",
+        }), /Max concurrent instances/);
+    });
+    it("does not count done/failed instances toward the limit", () => {
+        for (let i = 1; i <= MAX_CONCURRENT_INSTANCES; i++) {
+            const inst = createInstance({
+                id: `inst-done-${i}`,
+                masterSquadSlug: "test-squad",
+                worktreePath: `/tmp/wt/inst-done-${i}`,
+                branchName: `test-squad/instance/inst-done-${i}`,
+            });
+            updateInstanceStatus(inst.id, "done");
+        }
+        // Should not throw — all prior instances are done
+        assert.doesNotThrow(() => createInstance({
+            id: "inst-after-done",
+            masterSquadSlug: "test-squad",
+            worktreePath: "/tmp/wt/inst-after-done",
+            branchName: "test-squad/instance/inst-after-done",
+        }));
+    });
+});
+// ── getInstance ───────────────────────────────────────────────────────────────
+describe("getInstance", () => {
+    it("returns undefined for non-existent ID", () => {
+        assert.equal(getInstance("no-such-id"), undefined);
+    });
+    it("returns the correct instance after create", () => {
+        makeInstance("get-test");
+        const inst = getInstance("get-test");
+        assert.ok(inst);
+        assert.equal(inst.id, "get-test");
+    });
+});
+// ── listInstances ─────────────────────────────────────────────────────────────
+describe("listInstances", () => {
+    it("filters by slug and excludes done/failed by default", () => {
+        makeInstance("li-active-1");
+        makeInstance("li-active-2");
+        makeInstance("li-done", "test-squad", "done");
+        makeInstance("li-failed", "test-squad", "failed");
+        const active = listInstances("test-squad");
+        assert.equal(active.length, 2);
+        assert.ok(active.every((i) => i.status === "pending"));
+    });
+    it("includes completed instances when opted in", () => {
+        makeInstance("li-pending");
+        makeInstance("li-done2", "test-squad", "done");
+        const all = listInstances("test-squad", { includeCompleted: true });
+        assert.equal(all.length, 2);
+    });
+    it("does not include instances from other squads", () => {
+        getDb().prepare("INSERT INTO squads (slug, name, project_path) VALUES (?, ?, ?)").run("other-squad", "Other", "/tmp/other");
+        makeInstance("li-other", "other-squad");
+        makeInstance("li-mine");
+        const mine = listInstances("test-squad");
+        assert.equal(mine.length, 1);
+        assert.equal(mine[0].id, "li-mine");
+    });
+});
+// ── updateInstanceStatus ──────────────────────────────────────────────────────
+describe("updateInstanceStatus", () => {
+    it("sets completed_at for terminal status 'done'", () => {
+        makeInstance("upd-done");
+        updateInstanceStatus("upd-done", "done");
+        const inst = getInstance("upd-done");
+        assert.equal(inst.status, "done");
+        assert.ok(inst.completed_at !== null);
+    });
+    it("sets completed_at for terminal status 'failed'", () => {
+        makeInstance("upd-failed");
+        updateInstanceStatus("upd-failed", "failed");
+        const inst = getInstance("upd-failed");
+        assert.equal(inst.status, "failed");
+        assert.ok(inst.completed_at !== null);
+    });
+    it("does not set completed_at for non-terminal status 'active'", () => {
+        makeInstance("upd-active");
+        updateInstanceStatus("upd-active", "active");
+        const inst = getInstance("upd-active");
+        assert.equal(inst.status, "active");
+        assert.equal(inst.completed_at, null);
+    });
+});
+// ── logInstanceDecision + getInstanceDecisions ────────────────────────────────
+describe("logInstanceDecision / getInstanceDecisions", () => {
+    it("round-trips a decision with context", () => {
+        makeInstance("dec-inst");
+        logInstanceDecision("dec-inst", "use Jest for tests", "better DX");
+        const decisions = getInstanceDecisions("dec-inst");
+        assert.equal(decisions.length, 1);
+        assert.equal(decisions[0].decision, "use Jest for tests");
+        assert.equal(decisions[0].context, "better DX");
+        assert.equal(decisions[0].merged_to_master, 0);
+    });
+    it("stores null context when not provided", () => {
+        makeInstance("dec-nocontext");
+        logInstanceDecision("dec-nocontext", "some decision");
+        const decisions = getInstanceDecisions("dec-nocontext");
+        assert.equal(decisions[0].context, null);
+    });
+    it("returns decisions in ascending created_at order", () => {
+        makeInstance("dec-order");
+        logInstanceDecision("dec-order", "first");
+        logInstanceDecision("dec-order", "second");
+        const decisions = getInstanceDecisions("dec-order");
+        assert.equal(decisions[0].decision, "first");
+        assert.equal(decisions[1].decision, "second");
+    });
+});
+// ── mergeInstanceDecisions ────────────────────────────────────────────────────
+describe("mergeInstanceDecisions", () => {
+    it("copies decisions to squad_decisions with provenance tag and marks merged", () => {
+        makeInstance("merge-inst");
+        logInstanceDecision("merge-inst", "use SQLite transactions", "performance");
+        logInstanceDecision("merge-inst", "append-only log", "conflict-free");
+        const count = mergeInstanceDecisions("merge-inst", "test-squad");
+        assert.equal(count, 2);
+        const masterDecisions = getDecisions("test-squad");
+        assert.equal(masterDecisions.length, 2);
+        assert.ok(masterDecisions.some((d) => d.decision === "use SQLite transactions"));
+        assert.ok(masterDecisions.every((d) => d.context?.includes("[from instance: merge-inst]")));
+        const instDecisions = getInstanceDecisions("merge-inst");
+        assert.ok(instDecisions.every((d) => d.merged_to_master === 1));
+    });
+    it("is idempotent — calling twice does not double-merge", () => {
+        makeInstance("merge-idempotent");
+        logInstanceDecision("merge-idempotent", "idempotent decision");
+        mergeInstanceDecisions("merge-idempotent", "test-squad");
+        const second = mergeInstanceDecisions("merge-idempotent", "test-squad");
+        assert.equal(second, 0);
+        const masterDecisions = getDecisions("test-squad");
+        assert.equal(masterDecisions.length, 1);
+    });
+    it("returns 0 when there are no decisions to merge", () => {
+        makeInstance("merge-empty");
+        const count = mergeInstanceDecisions("merge-empty", "test-squad");
+        assert.equal(count, 0);
+    });
+});
+// ── deleteInstance ────────────────────────────────────────────────────────────
+describe("deleteInstance", () => {
+    it("removes the instance and its decisions", () => {
+        makeInstance("del-inst");
+        logInstanceDecision("del-inst", "a decision");
+        deleteInstance("del-inst");
+        assert.equal(getInstance("del-inst"), undefined);
+        assert.deepEqual(getInstanceDecisions("del-inst"), []);
+    });
+    it("is safe to call on a non-existent id", () => {
+        assert.doesNotThrow(() => deleteInstance("no-such-instance"));
+    });
+});
+// ── buildContextSnapshot ──────────────────────────────────────────────────────
+describe("buildContextSnapshot", () => {
+    it("returns a JSON array of recent squad decisions", () => {
+        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"));
+    });
+    it("returns an empty JSON array for a squad with no decisions", () => {
+        const snapshot = buildContextSnapshot("test-squad");
+        assert.deepEqual(JSON.parse(snapshot), []);
+    });
+    it("respects the limit parameter", () => {
+        for (let i = 0; i < 10; i++) {
+            logDecision("test-squad", `decision ${i}`);
+        }
+        const snapshot = buildContextSnapshot("test-squad", 5);
+        const parsed = JSON.parse(snapshot);
+        assert.equal(parsed.length, 5);
+    });
+});
+// ── reconcileInstances ────────────────────────────────────────────────────────
+describe("reconcileInstances", () => {
+    it("marks pending/active/merging instances failed when worktree does not exist", () => {
+        // These worktree paths do not exist on disk
+        makeInstance("recon-pending"); // status: pending
+        makeInstance("recon-active", "test-squad", "active"); // status: active
+        makeInstance("recon-merging", "test-squad", "merging"); // status: merging
+        const cleaned = reconcileInstances();
+        assert.equal(cleaned, 3);
+        assert.equal(getInstance("recon-pending").status, "failed");
+        assert.equal(getInstance("recon-active").status, "failed");
+        assert.equal(getInstance("recon-merging").status, "failed");
+    });
+    it("does not touch already-terminal instances", () => {
+        makeInstance("recon-done", "test-squad", "done");
+        makeInstance("recon-failed", "test-squad", "failed");
+        const cleaned = reconcileInstances();
+        assert.equal(cleaned, 0);
+    });
+    it("returns 0 when all non-terminal instances have valid worktrees", () => {
+        // Use a path that actually exists (tmpDir was created above)
+        createInstance({
+            id: "recon-exists",
+            masterSquadSlug: "test-squad",
+            worktreePath: tmpDir, // this path exists on disk
+            branchName: "test-squad/instance/recon-exists",
+        });
+        const cleaned = reconcileInstances();
+        assert.equal(cleaned, 0);
+        assert.equal(getInstance("recon-exists").status, "pending");
+    });
+});
+//# sourceMappingURL=instances.test.js.map

package/dist/store/tasks.js

@@ -1,7 +1,7 @@
 import { getDb } from "./db.js";
-export function createTask(taskId, agentSlug, description, originChannel) {
+export function createTask(taskId, agentSlug, description, originChannel, instanceId) {
     const db = getDb();
-    db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, origin_channel) VALUES (?, ?, ?, ?)").run(taskId, agentSlug, description, originChannel ?? null);
+    db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, origin_channel, instance_id) VALUES (?, ?, ?, ?, ?)").run(taskId, agentSlug, description, originChannel ?? null, instanceId ?? null);
     return getTask(taskId);
 }
 export function getTask(taskId) {

package/dist/store/tasks.test.js

@@ -0,0 +1,150 @@
+/**
+ * Tests for src/store/tasks.ts — agent task store.
+ *
+ * DB isolation: setDbPathForTests() redirects the SQLite singleton to a
+ * fresh tmp file so these tests never touch ~/.io/io.db.
+ */
+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 "./db.js";
+import { createTask, getTask, getActiveTasks, completeTask, failTask, cancelTask, listRecentTasks } from "./tasks.js";
+// ── DB isolation ─────────────────────────────────────────────────────────────
+let tmpDir;
+before(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "io-tasks-test-"));
+    setDbPathForTests(join(tmpDir, "io.db"));
+});
+after(() => {
+    closeDb();
+    rmSync(tmpDir, { recursive: true, force: true });
+});
+beforeEach(() => {
+    getDb().prepare("DELETE FROM agent_tasks").run();
+});
+// ── createTask / getTask ──────────────────────────────────────────────────────
+describe("createTask", () => {
+    it("creates a task with correct base fields", () => {
+        const task = createTask("t-base", "agent-1", "Do something");
+        assert.equal(task.task_id, "t-base");
+        assert.equal(task.agent_slug, "agent-1");
+        assert.equal(task.description, "Do something");
+        assert.equal(task.status, "running");
+        assert.equal(task.result, null);
+        assert.equal(task.origin_channel, null);
+        assert.ok(task.started_at);
+        assert.equal(task.completed_at, null);
+    });
+    it("stores null instance_id when not provided", () => {
+        const task = createTask("t-no-instance", "agent-1", "Do something");
+        assert.equal(task.instance_id, null);
+        const fetched = getTask("t-no-instance");
+        assert.equal(fetched?.instance_id, null);
+    });
+    it("stores instance_id when provided", () => {
+        const task = createTask("t-with-instance", "agent-1", "Do something", undefined, "test-squad--issue-42");
+        assert.equal(task.instance_id, "test-squad--issue-42");
+    });
+    it("stores origin_channel when provided", () => {
+        const task = createTask("t-channel", "agent-1", "Task", "telegram");
+        assert.equal(task.origin_channel, "telegram");
+    });
+    it("stores both origin_channel and instance_id together", () => {
+        const task = createTask("t-both", "agent-1", "Task", "telegram", "squad--issue-5");
+        assert.equal(task.origin_channel, "telegram");
+        assert.equal(task.instance_id, "squad--issue-5");
+    });
+});
+describe("getTask", () => {
+    it("returns undefined for non-existent task_id", () => {
+        assert.equal(getTask("no-such-task"), undefined);
+    });
+    it("returns instance_id field correctly from DB", () => {
+        createTask("t-fetch", "agent-2", "Fetch test", undefined, "squad--issue-99");
+        const fetched = getTask("t-fetch");
+        assert.ok(fetched);
+        assert.equal(fetched.instance_id, "squad--issue-99");
+        assert.equal(fetched.task_id, "t-fetch");
+    });
+    it("returns null instance_id for tasks created without one", () => {
+        createTask("t-fetch-null", "agent-2", "No instance");
+        const fetched = getTask("t-fetch-null");
+        assert.equal(fetched?.instance_id, null);
+    });
+});
+// ── getActiveTasks ────────────────────────────────────────────────────────────
+describe("getActiveTasks", () => {
+    it("returns only running tasks", () => {
+        createTask("t-run1", "agent-1", "Running 1");
+        createTask("t-run2", "agent-1", "Running 2");
+        const t = createTask("t-done", "agent-1", "Done task");
+        completeTask(t.task_id, "finished");
+        const active = getActiveTasks();
+        assert.equal(active.length, 2);
+        assert.ok(active.every((t) => t.status === "running"));
+    });
+    it("returns empty array when no running tasks", () => {
+        assert.deepEqual(getActiveTasks(), []);
+    });
+});
+// ── completeTask ──────────────────────────────────────────────────────────────
+describe("completeTask", () => {
+    it("sets status to done and records result and completed_at", () => {
+        createTask("t-complete", "agent-1", "Task to complete");
+        completeTask("t-complete", "all done");
+        const t = getTask("t-complete");
+        assert.equal(t?.status, "done");
+        assert.equal(t?.result, "all done");
+        assert.ok(t?.completed_at);
+    });
+});
+// ── failTask ──────────────────────────────────────────────────────────────────
+describe("failTask", () => {
+    it("sets status to failed and records error and completed_at", () => {
+        createTask("t-fail", "agent-1", "Task to fail");
+        failTask("t-fail", "something went wrong");
+        const t = getTask("t-fail");
+        assert.equal(t?.status, "failed");
+        assert.equal(t?.result, "something went wrong");
+        assert.ok(t?.completed_at);
+    });
+});
+// ── cancelTask ────────────────────────────────────────────────────────────────
+describe("cancelTask", () => {
+    it("cancels a running task with default reason", () => {
+        createTask("t-cancel", "agent-1", "Task to cancel");
+        cancelTask("t-cancel");
+        const t = getTask("t-cancel");
+        assert.equal(t?.status, "cancelled");
+        assert.ok(t?.result?.includes("Cancelled"));
+    });
+    it("does not cancel an already-completed task", () => {
+        createTask("t-cancel-done", "agent-1", "Already done");
+        completeTask("t-cancel-done", "done");
+        cancelTask("t-cancel-done");
+        // status should remain 'done'
+        assert.equal(getTask("t-cancel-done")?.status, "done");
+    });
+});
+// ── listRecentTasks ───────────────────────────────────────────────────────────
+describe("listRecentTasks", () => {
+    it("returns tasks newest first", () => {
+        createTask("t-list-1", "agent-1", "First");
+        createTask("t-list-2", "agent-1", "Second");
+        const tasks = listRecentTasks();
+        assert.equal(tasks.length, 2);
+        // Both should be present; newest (by insert order / task_id sort) first
+        assert.ok(tasks.some((t) => t.task_id === "t-list-1"));
+        assert.ok(tasks.some((t) => t.task_id === "t-list-2"));
+    });
+    it("respects limit", () => {
+        for (let i = 0; i < 5; i++) {
+            createTask(`t-limit-${i}`, "agent-1", `Task ${i}`);
+        }
+        const tasks = listRecentTasks(3);
+        assert.equal(tasks.length, 3);
+    });
+});
+//# sourceMappingURL=tasks.test.js.map

package/dist/store/worktrees.js

@@ -0,0 +1,83 @@
+import { execSync } from "child_process";
+import { existsSync, rmSync, mkdirSync } from "fs";
+import path from "path";
+/**
+ * Create a git worktree for a squad instance.
+ * @param projectPath - The main project directory (must be a git repo)
+ * @param instanceId - Used to name the worktree subdirectory
+ * @param branchName - The branch to create for this worktree
+ * @param baseBranch - The branch to base the worktree on (default: "main")
+ * @returns The absolute path to the created worktree
+ */
+export function createWorktree(projectPath, instanceId, branchName, baseBranch = "main") {
+    const worktreeDir = path.join(projectPath, ".io-worktrees", instanceId);
+    const parentDir = path.join(projectPath, ".io-worktrees");
+    if (!existsSync(parentDir)) {
+        mkdirSync(parentDir, { recursive: true });
+    }
+    // Fetch latest to ensure base branch is up to date
+    try {
+        execSync(`git fetch origin ${baseBranch}`, { cwd: projectPath, stdio: "pipe" });
+    }
+    catch {
+        // Best effort — might be offline or no remote
+    }
+    // Create the worktree with a new branch from the base
+    execSync(`git worktree add "${worktreeDir}" -b "${branchName}" "origin/${baseBranch}"`, { cwd: projectPath, stdio: "pipe" });
+    return worktreeDir;
+}
+/**
+ * Remove a git worktree. Falls back to rm -rf + prune if git remove fails.
+ */
+export function removeWorktree(projectPath, worktreePath) {
+    try {
+        execSync(`git worktree remove "${worktreePath}" --force`, {
+            cwd: projectPath,
+            stdio: "pipe",
+        });
+    }
+    catch {
+        // Fallback: force remove directory and prune
+        if (existsSync(worktreePath)) {
+            rmSync(worktreePath, { recursive: true, force: true });
+        }
+        try {
+            execSync("git worktree prune", { cwd: projectPath, stdio: "pipe" });
+        }
+        catch {
+            // best effort
+        }
+    }
+}
+/**
+ * List all worktrees for a project.
+ */
+export function listWorktrees(projectPath) {
+    try {
+        const output = execSync("git worktree list --porcelain", {
+            cwd: projectPath,
+            encoding: "utf-8",
+        });
+        const entries = [];
+        let currentPath = "";
+        for (const line of output.split("\n")) {
+            if (line.startsWith("worktree ")) {
+                currentPath = line.slice("worktree ".length);
+            }
+            else if (line.startsWith("branch ")) {
+                entries.push({ path: currentPath, branch: line.slice("branch refs/heads/".length) });
+            }
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Check if a worktree path exists on disk.
+ */
+export function worktreeExists(worktreePath) {
+    return existsSync(worktreePath);
+}
+//# sourceMappingURL=worktrees.js.map