heyio 4.0.7 → 4.1.0

package/dist/daemon/cli.js

@@ -80,7 +80,7 @@ var init_constants = __esm({
   "packages/shared/dist/constants.js"() {
     "use strict";
     APP_NAME = "io";
-    APP_VERSION = "4.0.7";
+    APP_VERSION = "4.1.0";
     API_PORT = 7777;
     API_HOST = "0.0.0.0";
     DEFAULT_MODEL = "gpt-4o";
@@ -92,6 +92,11 @@ var init_constants = __esm({
       SQUAD_CREATED: "squad.created",
       SQUAD_DELETED: "squad.deleted",
       SQUAD_UPDATED: "squad.updated",
+      INSTANCE_CREATED: "instance.created",
+      INSTANCE_STARTED: "instance.started",
+      INSTANCE_COMPLETED: "instance.completed",
+      INSTANCE_FAILED: "instance.failed",
+      INSTANCE_CANCELLED: "instance.cancelled",
       OBJECTIVE_STARTED: "objective.started",
       OBJECTIVE_COMPLETED: "objective.completed",
       OBJECTIVE_FAILED: "objective.failed",
@@ -2085,6 +2090,27 @@ var init_db = __esm({
           "ALTER TABLE token_usage ADD COLUMN premium_request_cost REAL",
           "ALTER TABLE token_usage ADD COLUMN token_unit_cost REAL"
         ]
+      },
+      {
+        version: 3,
+        name: "add-squad-instances",
+        statements: [
+          `CREATE TABLE IF NOT EXISTS squad_instances (
+				id TEXT PRIMARY KEY,
+				squad_id TEXT NOT NULL REFERENCES squads(id) ON DELETE CASCADE,
+				objective_id TEXT REFERENCES objectives(id) ON DELETE SET NULL,
+				status TEXT NOT NULL DEFAULT 'queued',
+				branch TEXT,
+				worktree_path TEXT,
+				created_at TEXT NOT NULL,
+				started_at TEXT,
+				completed_at TEXT,
+				error TEXT
+			)`,
+          "CREATE INDEX IF NOT EXISTS idx_squad_instances_squad_status ON squad_instances(squad_id, status)",
+          "CREATE INDEX IF NOT EXISTS idx_squad_instances_status ON squad_instances(status)",
+          "CREATE INDEX IF NOT EXISTS idx_squad_instances_objective_id ON squad_instances(objective_id)"
+        ]
       }
     ];
     client = null;
@@ -11852,87 +11878,6 @@ async function recordUsage(data, db) {
   });
   return usage;
 }
-async function getUsageSummary(params = {}, db) {
-  const database = db ?? await getDatabase();
-  const filter = buildUsageFilter(params);
-  const [totalsResult, bySquadResult, byAgentResult, byModelResult, daily] = await Promise.all([
-    database.execute({
-      sql: `SELECT COALESCE(SUM(input_tokens), 0) AS total_input_tokens,
-			             COALESCE(SUM(output_tokens), 0) AS total_output_tokens,
-			             COALESCE(SUM(cost), 0) AS total_cost
-			      FROM token_usage ${filter.clause}`,
-      args: filter.args
-    }),
-    database.execute({
-      sql: `SELECT tu.squad_id,
-			             COALESCE(s.name, tu.squad_id, 'Unknown squad') AS squad_name,
-			             COALESCE(SUM(tu.input_tokens), 0) AS input_tokens,
-			             COALESCE(SUM(tu.output_tokens), 0) AS output_tokens,
-			             COALESCE(SUM(tu.cost), 0) AS cost
-			      FROM token_usage tu
-			      LEFT JOIN squads s ON s.id = tu.squad_id
-			      ${filter.clause.replaceAll("created_at", "tu.created_at").replaceAll("squad_id", "tu.squad_id").replaceAll("agent_id", "tu.agent_id").replaceAll("model", "tu.model")}
-			      AND tu.squad_id IS NOT NULL
-			      GROUP BY tu.squad_id, squad_name
-			      ORDER BY cost DESC, input_tokens DESC`,
-      args: filter.args
-    }),
-    database.execute({
-      sql: `SELECT tu.agent_id,
-			             COALESCE(sm.name, tu.agent_id, 'Unknown agent') AS agent_name,
-			             COALESCE(tu.squad_id, '') AS squad_id,
-			             COALESCE(SUM(tu.input_tokens), 0) AS input_tokens,
-			             COALESCE(SUM(tu.output_tokens), 0) AS output_tokens,
-			             COALESCE(SUM(tu.cost), 0) AS cost
-			      FROM token_usage tu
-			      LEFT JOIN squad_members sm ON sm.id = tu.agent_id
-			      ${filter.clause.replaceAll("created_at", "tu.created_at").replaceAll("squad_id", "tu.squad_id").replaceAll("agent_id", "tu.agent_id").replaceAll("model", "tu.model")}
-			      AND tu.agent_id IS NOT NULL
-			      GROUP BY tu.agent_id, agent_name, tu.squad_id
-			      ORDER BY cost DESC, input_tokens DESC`,
-      args: filter.args
-    }),
-    database.execute({
-      sql: `SELECT model,
-			             COALESCE(SUM(input_tokens), 0) AS input_tokens,
-			             COALESCE(SUM(output_tokens), 0) AS output_tokens,
-			             COALESCE(SUM(cost), 0) AS cost
-			      FROM token_usage ${filter.clause}
-			      GROUP BY model
-			      ORDER BY cost DESC, input_tokens DESC`,
-      args: filter.args
-    }),
-    getDailyUsage(params.startDate ?? null, params.endDate ?? null, params, database)
-  ]);
-  const totals = totalsResult.rows[0];
-  return {
-    totalInputTokens: totals ? asNumber(totals.total_input_tokens) : 0,
-    totalOutputTokens: totals ? asNumber(totals.total_output_tokens) : 0,
-    totalCost: totals ? asNumber(totals.total_cost) : 0,
-    bySquad: bySquadResult.rows.map((row) => ({
-      squadId: asString(row.squad_id),
-      squadName: asString(row.squad_name),
-      inputTokens: asNumber(row.input_tokens),
-      outputTokens: asNumber(row.output_tokens),
-      cost: asNumber(row.cost)
-    })),
-    byAgent: byAgentResult.rows.map((row) => ({
-      agentId: asString(row.agent_id),
-      agentName: asString(row.agent_name),
-      squadId: asString(row.squad_id),
-      inputTokens: asNumber(row.input_tokens),
-      outputTokens: asNumber(row.output_tokens),
-      cost: asNumber(row.cost)
-    })),
-    byModel: byModelResult.rows.map((row) => ({
-      model: asString(row.model),
-      inputTokens: asNumber(row.input_tokens),
-      outputTokens: asNumber(row.output_tokens),
-      cost: asNumber(row.cost)
-    })),
-    daily
-  };
-}
 async function getDailyUsage(startDate, endDate, params = {}, db) {
   const database = db ?? await getDatabase();
   const filter = buildUsageFilter({
@@ -11985,6 +11930,51 @@ function buildUsageFilter(params) {
     args
   };
 }
+async function getUsageRecords(params = {}, db) {
+  const database = db ?? await getDatabase();
+  const filter = buildUsageFilter(params);
+  const aliasedClause = filter.clause.replaceAll("created_at", "tu.created_at").replaceAll("squad_id", "tu.squad_id").replaceAll("agent_id", "tu.agent_id").replaceAll("model", "tu.model");
+  const result = await database.execute({
+    sql: `SELECT tu.model, tu.input_tokens, tu.output_tokens, tu.cost,
+		             tu.created_at, tu.squad_id, tu.agent_id,
+		             COALESCE(s.name, '') AS squad_name,
+		             COALESCE(sm.name, '') AS agent_name
+		      FROM token_usage tu
+		      LEFT JOIN squads s ON s.id = tu.squad_id
+		      LEFT JOIN squad_members sm ON sm.id = tu.agent_id
+		      ${aliasedClause}
+		      ORDER BY tu.created_at DESC
+		      LIMIT 10000`,
+    args: filter.args
+  });
+  const records = result.rows.map((row) => ({
+    model: asString(row.model),
+    inputTokens: asNumber(row.input_tokens),
+    outputTokens: asNumber(row.output_tokens),
+    estimatedCostUsd: asNumber(row.cost),
+    timestamp: asString(row.created_at),
+    squadId: asNullableString(row.squad_id),
+    squadName: asNullableString(row.squad_name) || null,
+    agentRole: asNullableString(row.agent_name) || null
+  }));
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalCostUsd = 0;
+  for (const r of records) {
+    totalInputTokens += r.inputTokens;
+    totalOutputTokens += r.outputTokens;
+    totalCostUsd += r.estimatedCostUsd ?? 0;
+  }
+  return {
+    records,
+    totals: {
+      totalInputTokens,
+      totalOutputTokens,
+      totalCostUsd,
+      callCount: records.length
+    }
+  };
+}
 var init_token_usage = __esm({
   "packages/daemon/src/store/token-usage.ts"() {
     "use strict";
@@ -12292,6 +12282,141 @@ var init_objectives = __esm({
   }
 });
 
+// packages/daemon/src/store/instances.ts
+async function createInstance(input2, db) {
+  const database = db ?? await getDatabase();
+  const instance = {
+    id: generateId(),
+    squadId: input2.squadId,
+    objectiveId: input2.objectiveId ?? null,
+    status: "queued",
+    branch: input2.branch ?? null,
+    worktreePath: null,
+    createdAt: nowIso(),
+    startedAt: null,
+    completedAt: null,
+    error: null
+  };
+  await database.execute({
+    sql: `INSERT INTO squad_instances (id, squad_id, objective_id, status, branch, worktree_path, created_at, started_at, completed_at, error)
+		      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      instance.id,
+      instance.squadId,
+      instance.objectiveId,
+      instance.status,
+      instance.branch,
+      instance.worktreePath,
+      instance.createdAt,
+      instance.startedAt,
+      instance.completedAt,
+      instance.error
+    ]
+  });
+  return instance;
+}
+async function getInstance(instanceId, db) {
+  const database = db ?? await getDatabase();
+  const result = await database.execute({
+    sql: "SELECT * FROM squad_instances WHERE id = ?",
+    args: [instanceId]
+  });
+  return result.rows[0] ? mapRow(result.rows[0]) : null;
+}
+async function listInstancesBySquad(squadId, db) {
+  const database = db ?? await getDatabase();
+  const result = await database.execute({
+    sql: "SELECT * FROM squad_instances WHERE squad_id = ? ORDER BY created_at DESC",
+    args: [squadId]
+  });
+  return result.rows.map(mapRow);
+}
+async function listActiveInstances(squadId, db) {
+  const database = db ?? await getDatabase();
+  const result = await database.execute({
+    sql: "SELECT * FROM squad_instances WHERE squad_id = ? AND status IN ('queued', 'running', 'completing') ORDER BY created_at ASC",
+    args: [squadId]
+  });
+  return result.rows.map(mapRow);
+}
+async function countRunningInstances(squadId, db) {
+  const database = db ?? await getDatabase();
+  const result = await database.execute({
+    sql: "SELECT COUNT(*) AS cnt FROM squad_instances WHERE squad_id = ? AND status = 'running'",
+    args: [squadId]
+  });
+  return result.rows[0] ? asNumber(result.rows[0].cnt) : 0;
+}
+async function getNextQueued(squadId, db) {
+  const database = db ?? await getDatabase();
+  const result = await database.execute({
+    sql: "SELECT * FROM squad_instances WHERE squad_id = ? AND status = 'queued' ORDER BY created_at ASC LIMIT 1",
+    args: [squadId]
+  });
+  return result.rows[0] ? mapRow(result.rows[0]) : null;
+}
+async function updateInstanceStatus(instanceId, status, updates, db) {
+  const database = db ?? await getDatabase();
+  const now = nowIso();
+  const sets = ["status = ?"];
+  const args = [status];
+  if (status === "running") {
+    sets.push("started_at = ?");
+    args.push(now);
+  }
+  if (status === "completed" || status === "failed" || status === "cancelled") {
+    sets.push("completed_at = ?");
+    args.push(now);
+  }
+  if (updates?.branch) {
+    sets.push("branch = ?");
+    args.push(updates.branch);
+  }
+  if (updates?.worktreePath) {
+    sets.push("worktree_path = ?");
+    args.push(updates.worktreePath);
+  }
+  if (updates?.error) {
+    sets.push("error = ?");
+    args.push(updates.error);
+  }
+  args.push(instanceId);
+  await database.execute({
+    sql: `UPDATE squad_instances SET ${sets.join(", ")} WHERE id = ?`,
+    args
+  });
+  return getInstance(instanceId, database);
+}
+async function findStaleInstances(db) {
+  const database = db ?? await getDatabase();
+  const cutoff = new Date(Date.now() - 6 * 60 * 60 * 1e3).toISOString();
+  const result = await database.execute({
+    sql: "SELECT * FROM squad_instances WHERE status = 'running' AND started_at < ?",
+    args: [cutoff]
+  });
+  return result.rows.map(mapRow);
+}
+function mapRow(row) {
+  return {
+    id: asString(row.id),
+    squadId: asString(row.squad_id),
+    objectiveId: asNullableString(row.objective_id),
+    status: asString(row.status),
+    branch: asNullableString(row.branch),
+    worktreePath: asNullableString(row.worktree_path),
+    createdAt: asString(row.created_at),
+    startedAt: asNullableString(row.started_at),
+    completedAt: asNullableString(row.completed_at),
+    error: asNullableString(row.error)
+  };
+}
+var init_instances = __esm({
+  "packages/daemon/src/store/instances.ts"() {
+    "use strict";
+    init_db();
+  }
+});
+
 // packages/daemon/src/store/index.ts
 var init_store2 = __esm({
   "packages/daemon/src/store/index.ts"() {
@@ -12305,6 +12430,7 @@ var init_store2 = __esm({
     init_activity();
     init_agent_history();
     init_objectives();
+    init_instances();
   }
 });
 
@@ -31174,7 +31300,7 @@ var require_view = __commonJS({
     var dirname9 = path.dirname;
     var basename6 = path.basename;
     var extname4 = path.extname;
-    var join15 = path.join;
+    var join16 = path.join;
     var resolve5 = path.resolve;
     module2.exports = View;
     function View(name, options2) {
@@ -31236,12 +31362,12 @@ var require_view = __commonJS({
     };
     View.prototype.resolve = function resolve6(dir, file2) {
       var ext = this.ext;
-      var path2 = join15(dir, file2);
+      var path2 = join16(dir, file2);
       var stat4 = tryStat(path2);
       if (stat4 && stat4.isFile()) {
         return path2;
       }
-      path2 = join15(dir, basename6(file2, ext), "index" + ext);
+      path2 = join16(dir, basename6(file2, ext), "index" + ext);
       stat4 = tryStat(path2);
       if (stat4 && stat4.isFile()) {
         return path2;
@@ -34946,7 +35072,7 @@ var require_send = __commonJS({
     var Stream = __require("stream");
     var util = __require("util");
     var extname4 = path.extname;
-    var join15 = path.join;
+    var join16 = path.join;
     var normalize = path.normalize;
     var resolve5 = path.resolve;
     var sep = path.sep;
@@ -35118,7 +35244,7 @@ var require_send = __commonJS({
           return res;
         }
         parts = path2.split(sep);
-        path2 = normalize(join15(root, path2));
+        path2 = normalize(join16(root, path2));
       } else {
         if (UP_PATH_REGEXP.test(path2)) {
           debug('malicious path "%s"', path2);
@@ -35251,7 +35377,7 @@ var require_send = __commonJS({
           if (err) return self.onStatError(err);
           return self.error(404);
         }
-        var p = join15(path2, self._index[i]);
+        var p = join16(path2, self._index[i]);
         debug('stat "%s"', p);
         fs.stat(p, function(err2, stat4) {
           if (err2) return next(err2);
@@ -51511,6 +51637,10 @@ var init_zod = __esm({
 });
 
 // packages/daemon/src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  loadConfig: () => loadConfig
+});
 import { existsSync, readFileSync } from "node:fs";
 function parseConfigFile() {
   if (!existsSync(CONFIG_PATH)) {
@@ -51593,7 +51723,8 @@ var init_config = __esm({
       supabaseUrl: external_exports.string().trim().min(1).nullable().default(null),
       supabaseAnonKey: external_exports.string().trim().min(1).nullable().default(null),
       sessionResetThreshold: external_exports.coerce.number().int().positive().default(SESSION_RESET_THRESHOLD),
-      pricingRefreshHours: external_exports.coerce.number().positive().default(24)
+      pricingRefreshHours: external_exports.coerce.number().positive().default(24),
+      maxInstancesPerSquad: external_exports.coerce.number().int().positive().default(3)
     });
   }
 });
@@ -51717,6 +51848,36 @@ var init_settings = __esm({
 // packages/daemon/src/api/routes/skills.ts
 import { mkdir as mkdir3, readFile as readFile2, rm, writeFile as writeFile2 } from "node:fs/promises";
 import { basename, extname, join as join3 } from "node:path";
+async function getSkillContent(skill) {
+  if (!skill.entryFile) return "";
+  const filePath = join3(SKILLS_DIR, skill.directory, skill.entryFile);
+  try {
+    return await readFile2(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+function extractDescription(content) {
+  const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
+  return lines[0]?.trim().slice(0, 200) ?? "";
+}
+function extractPreview(content) {
+  return content.slice(0, 300);
+}
+async function buildSkillSummaries(skills) {
+  return Promise.all(
+    skills.map(async (skill) => {
+      const content = await getSkillContent(skill);
+      return {
+        name: skill.slug,
+        activatedForOrchestrator: true,
+        preview: extractPreview(content),
+        description: extractDescription(content),
+        filePath: skill.entryFile ? join3(SKILLS_DIR, skill.directory, skill.entryFile) : join3(SKILLS_DIR, skill.directory)
+      };
+    })
+  );
+}
 async function installSkill(request) {
   await mkdir3(SKILLS_DIR, { recursive: true });
   const installedSkills = await readInstalledSkills();
@@ -51774,6 +51935,16 @@ async function removeSkill(skillId) {
   await writeSkillsLock(installedSkills.filter((entry) => entry.id !== skillId));
   return true;
 }
+async function removeSkillBySlug(slug) {
+  const installedSkills = await readInstalledSkills();
+  const skill = installedSkills.find((entry) => entry.slug === slug);
+  if (!skill) {
+    return false;
+  }
+  await rm(skill.directory, { recursive: true, force: true });
+  await writeSkillsLock(installedSkills.filter((entry) => entry.slug !== slug));
+  return true;
+}
 async function readInstalledSkills() {
   try {
     const raw = await readFile2(SKILLS_LOCK_PATH, "utf8");
@@ -51943,7 +52114,9 @@ var init_skills = __esm({
     router6 = (0, import_express6.Router)();
     router6.get("/api/skills", async (_req, res) => {
       try {
-        res.status(200).json(await readInstalledSkills());
+        const skills = await readInstalledSkills();
+        const summaries = await buildSkillSummaries(skills);
+        res.status(200).json({ skills: summaries });
       } catch (error51) {
         res.status(500).json({
           error: "Failed to list skills",
@@ -51951,6 +52124,71 @@ var init_skills = __esm({
         });
       }
     });
+    router6.get("/api/skills/discover", async (req, res) => {
+      try {
+        const source = typeof req.query.source === "string" ? req.query.source : "";
+        const query = typeof req.query.q === "string" ? req.query.q.trim() : "";
+        if (source === "skillssh") {
+          const skills = await discoverSkillsSh(query);
+          res.status(200).json({ skills });
+        } else if (source === "awesome-copilot") {
+          const skills = await discoverAwesomeCopilot(query);
+          res.status(200).json({ skills });
+        } else {
+          res.status(400).json({ error: `Unknown source: ${source}` });
+        }
+      } catch (error51) {
+        res.status(500).json({
+          error: "Failed to discover skills",
+          details: error51 instanceof Error ? error51.message : "Unknown error"
+        });
+      }
+    });
+    router6.get("/api/skills/:name", async (req, res) => {
+      try {
+        const skills = await readInstalledSkills();
+        const skill = skills.find((s) => s.slug === req.params.name);
+        if (!skill) {
+          res.status(404).json({ error: "Skill not found" });
+          return;
+        }
+        const content = await getSkillContent(skill);
+        const filePath = skill.entryFile ? join3(SKILLS_DIR, skill.directory, skill.entryFile) : join3(SKILLS_DIR, skill.directory);
+        res.status(200).json({ name: skill.slug, content, filePath });
+      } catch (error51) {
+        res.status(500).json({
+          error: "Failed to get skill",
+          details: error51 instanceof Error ? error51.message : "Unknown error"
+        });
+      }
+    });
+    router6.put("/api/skills/:name", async (req, res) => {
+      try {
+        const skills = await readInstalledSkills();
+        const skill = skills.find((s) => s.slug === req.params.name);
+        if (!skill) {
+          res.status(404).json({ error: "Skill not found" });
+          return;
+        }
+        if (!skill.entryFile) {
+          res.status(400).json({ error: "Skill has no entry file to update" });
+          return;
+        }
+        const { content } = req.body;
+        if (typeof content !== "string") {
+          res.status(400).json({ error: "content is required" });
+          return;
+        }
+        const filePath = join3(SKILLS_DIR, skill.directory, skill.entryFile);
+        await writeFile2(filePath, content, "utf8");
+        res.status(200).json({ name: skill.slug, content, filePath });
+      } catch (error51) {
+        res.status(500).json({
+          error: "Failed to update skill",
+          details: error51 instanceof Error ? error51.message : "Unknown error"
+        });
+      }
+    });
     router6.post("/api/skills/install", async (req, res) => {
       try {
         const body = req.body;
@@ -51975,10 +52213,14 @@ var init_skills = __esm({
     });
     router6.delete("/api/skills/:id", async (req, res) => {
       try {
-        const removed = await removeSkill(req.params.id);
+        const identifier = req.params.id;
+        const removed = await removeSkill(identifier);
         if (!removed) {
-          res.status(404).json({ error: "Skill not found" });
-          return;
+          const removedBySlug = await removeSkillBySlug(identifier);
+          if (!removedBySlug) {
+            res.status(404).json({ error: "Skill not found" });
+            return;
+          }
         }
         res.status(200).json({ deleted: true });
       } catch (error51) {
@@ -51988,31 +52230,311 @@ var init_skills = __esm({
         });
       }
     });
-    router6.get("/api/skills/discover", async (req, res) => {
-      try {
-        const source = typeof req.query.source === "string" ? req.query.source : "";
-        const query = typeof req.query.q === "string" ? req.query.q.trim() : "";
-        if (source === "skillssh") {
-          const skills = await discoverSkillsSh(query);
-          res.status(200).json(skills);
-        } else if (source === "awesome-copilot") {
-          const skills = await discoverAwesomeCopilot(query);
-          res.status(200).json(skills);
-        } else {
-          res.status(400).json({ error: `Unknown source: ${source}` });
-        }
-      } catch (error51) {
-        res.status(500).json({
-          error: "Failed to discover skills",
-          details: error51 instanceof Error ? error51.message : "Unknown error"
-        });
-      }
-    });
     awesomeCopilotCache = null;
     AWESOME_COPILOT_CACHE_TTL = 60 * 60 * 1e3;
   }
 });
 
+// packages/daemon/src/execution/worktree.ts
+import { exec } from "node:child_process";
+import { mkdir as mkdir4, rm as rm2 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+import { promisify } from "node:util";
+function sanitizeBranchName(branchName) {
+  return branchName.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+async function runGit(command, cwd) {
+  const { stdout } = await execAsync(command, {
+    cwd,
+    ...EXEC_OPTIONS
+  });
+  return stdout.trim();
+}
+async function branchExists(repoPath, branchName) {
+  const output2 = await runGit(`git branch --list ${JSON.stringify(branchName)}`, repoPath);
+  return output2.length > 0;
+}
+function getWorktreePath(repoPath, branchName) {
+  return join4(repoPath, ".worktrees", sanitizeBranchName(branchName));
+}
+async function listWorktrees(repoPath) {
+  const output2 = await runGit("git worktree list --porcelain", repoPath);
+  if (!output2) {
+    return [];
+  }
+  const blocks = output2.split(/\r?\n\r?\n/).filter(Boolean);
+  return blocks.map((block) => {
+    const info = {
+      path: "",
+      branch: null,
+      head: null,
+      bare: false,
+      detached: false,
+      locked: false,
+      prunable: false
+    };
+    for (const line of block.split(/\r?\n/)) {
+      const [key, ...rest] = line.split(" ");
+      const value = rest.join(" ").trim();
+      switch (key) {
+        case "worktree":
+          info.path = value;
+          break;
+        case "branch":
+          info.branch = value.replace(/^refs\/heads\//, "");
+          break;
+        case "HEAD":
+          info.head = value;
+          break;
+        case "bare":
+          info.bare = true;
+          break;
+        case "detached":
+          info.detached = true;
+          break;
+        case "locked":
+          info.locked = true;
+          break;
+        case "prunable":
+          info.prunable = true;
+          break;
+      }
+    }
+    return info;
+  });
+}
+async function createWorktree(repoPath, branchName, baseBranch) {
+  const worktreePath = getWorktreePath(repoPath, branchName);
+  await mkdir4(join4(repoPath, ".worktrees"), { recursive: true });
+  const existing = (await listWorktrees(repoPath)).find(
+    (worktree) => worktree.path === worktreePath
+  );
+  if (existing) {
+    return worktreePath;
+  }
+  const startPoint = baseBranch?.trim();
+  const createNewBranch = !await branchExists(repoPath, branchName);
+  const command = createNewBranch ? `git worktree add ${JSON.stringify(worktreePath)} -b ${JSON.stringify(branchName)}${startPoint ? ` ${JSON.stringify(startPoint)}` : ""}` : `git worktree add ${JSON.stringify(worktreePath)} ${JSON.stringify(branchName)}`;
+  try {
+    await runGit(command, repoPath);
+    return worktreePath;
+  } catch (error51) {
+    const message2 = error51 instanceof Error ? error51.message : String(error51);
+    if (/already exists/i.test(message2)) {
+      return worktreePath;
+    }
+    throw new Error(`Failed to create worktree for ${branchName}: ${message2}`);
+  }
+}
+async function cleanupWorktree(worktreePath) {
+  const parentRepoPath = join4(worktreePath, "..", "..");
+  try {
+    await runGit(`git worktree remove ${JSON.stringify(worktreePath)}`, parentRepoPath);
+  } catch (error51) {
+    const message2 = error51 instanceof Error ? error51.message : String(error51);
+    if (!/not a working tree/i.test(message2) && !/does not exist/i.test(message2)) {
+      await runGit(
+        `git worktree remove --force ${JSON.stringify(worktreePath)}`,
+        parentRepoPath
+      ).catch(() => void 0);
+    }
+  }
+  await runGit("git worktree prune", parentRepoPath).catch(() => void 0);
+  await rm2(worktreePath, { recursive: true, force: true }).catch(() => void 0);
+}
+async function pushBranch(worktreePath, remote = DEFAULT_REMOTE) {
+  const branchName = await runGit("git branch --show-current", worktreePath);
+  if (!branchName) {
+    throw new Error(`Unable to determine branch for worktree ${worktreePath}`);
+  }
+  const output2 = await runGit(
+    `git push --set-upstream ${JSON.stringify(remote)} ${JSON.stringify(branchName)}`,
+    worktreePath
+  );
+  return { branchName, remote, output: output2 };
+}
+var execAsync, DEFAULT_REMOTE, EXEC_OPTIONS;
+var init_worktree = __esm({
+  "packages/daemon/src/execution/worktree.ts"() {
+    "use strict";
+    execAsync = promisify(exec);
+    DEFAULT_REMOTE = "origin";
+    EXEC_OPTIONS = { maxBuffer: 10 * 1024 * 1024 };
+  }
+});
+
+// packages/daemon/src/execution/instances.ts
+import { mkdir as mkdir5, readdir, rename, rm as rm3 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+async function spawnInstance(input2) {
+  const config2 = loadConfig();
+  const instance = await createInstance(input2);
+  emitInstanceEvent(EVENT_NAMES.INSTANCE_CREATED, instance);
+  await cleanStaleInstances();
+  const running = await countRunningInstances(input2.squadId);
+  if (running < config2.maxInstancesPerSquad) {
+    return { instance, queued: false };
+  }
+  return { instance, queued: true };
+}
+async function startInstance(instanceId, repoPath, baseBranch) {
+  const branchName = `squad/instance-${instanceId.slice(0, 8)}`;
+  try {
+    const { exec: exec8 } = await import("node:child_process");
+    const { promisify: promisify8 } = await import("node:util");
+    const execAsync8 = promisify8(exec8);
+    await execAsync8(`git fetch origin && git pull origin ${baseBranch}`, {
+      cwd: repoPath,
+      maxBuffer: 10 * 1024 * 1024
+    });
+  } catch {
+  }
+  const worktreePath = await createWorktree(repoPath, branchName, baseBranch);
+  const updated = await updateInstanceStatus(instanceId, "running", {
+    branch: branchName,
+    worktreePath
+  });
+  if (!updated) {
+    throw new Error(`Instance ${instanceId} not found during start`);
+  }
+  emitInstanceEvent(EVENT_NAMES.INSTANCE_STARTED, updated);
+  return updated;
+}
+async function completeInstance(instanceId) {
+  const instance = await getInstance(instanceId);
+  if (!instance) {
+    throw new Error(`Instance ${instanceId} not found`);
+  }
+  await mergeWikiPages(instance);
+  if (instance.worktreePath) {
+    await cleanupWorktree(instance.worktreePath).catch(() => {
+    });
+  }
+  const updated = await updateInstanceStatus(instanceId, "completed");
+  if (!updated) {
+    throw new Error(`Instance ${instanceId} not found during completion`);
+  }
+  emitInstanceEvent(EVENT_NAMES.INSTANCE_COMPLETED, updated);
+  await processQueue(instance.squadId);
+  return updated;
+}
+async function failInstance(instanceId, error51) {
+  const instance = await getInstance(instanceId);
+  if (!instance) {
+    throw new Error(`Instance ${instanceId} not found`);
+  }
+  await cleanupPendingWiki(instance);
+  if (instance.worktreePath) {
+    await cleanupWorktree(instance.worktreePath).catch(() => {
+    });
+  }
+  const updated = await updateInstanceStatus(instanceId, "failed", { error: error51 });
+  if (!updated) {
+    throw new Error(`Instance ${instanceId} not found during failure`);
+  }
+  emitInstanceEvent(EVENT_NAMES.INSTANCE_FAILED, updated);
+  await processQueue(instance.squadId);
+  return updated;
+}
+async function cancelInstance(instanceId) {
+  const instance = await getInstance(instanceId);
+  if (!instance) {
+    throw new Error(`Instance ${instanceId} not found`);
+  }
+  await cleanupPendingWiki(instance);
+  if (instance.worktreePath) {
+    await cleanupWorktree(instance.worktreePath).catch(() => {
+    });
+  }
+  const updated = await updateInstanceStatus(instanceId, "cancelled");
+  if (!updated) {
+    throw new Error(`Instance ${instanceId} not found during cancellation`);
+  }
+  emitInstanceEvent(EVENT_NAMES.INSTANCE_CANCELLED, updated);
+  await processQueue(instance.squadId);
+  return updated;
+}
+async function processQueue(squadId) {
+  const config2 = loadConfig();
+  await cleanStaleInstances();
+  const running = await countRunningInstances(squadId);
+  if (running >= config2.maxInstancesPerSquad) {
+    return;
+  }
+  const next = await getNextQueued(squadId);
+  if (!next) {
+    return;
+  }
+  emitInstanceEvent(EVENT_NAMES.INSTANCE_STARTED, next);
+}
+async function cleanStaleInstances() {
+  const stale = await findStaleInstances();
+  for (const instance of stale) {
+    if (instance.worktreePath) {
+      await cleanupWorktree(instance.worktreePath).catch(() => {
+      });
+    }
+    await cleanupPendingWiki(instance);
+    await updateInstanceStatus(instance.id, "failed", {
+      error: "Instance timed out (stale detection)"
+    });
+    emitInstanceEvent(EVENT_NAMES.INSTANCE_FAILED, instance);
+  }
+}
+function getWikiPendingDir(instance) {
+  return join5(WIKI_DIR, ".pending", instance.id);
+}
+async function mergeWikiPages(instance) {
+  const pendingDir = getWikiPendingDir(instance);
+  try {
+    const entries = await readdir(pendingDir, { withFileTypes: true });
+    if (entries.length === 0) {
+      await rm3(pendingDir, { recursive: true, force: true });
+      return;
+    }
+    await mkdir5(WIKI_DIR, { recursive: true });
+    for (const entry of entries) {
+      const source = join5(pendingDir, entry.name);
+      const dest = join5(WIKI_DIR, entry.name);
+      await rename(source, dest).catch(async () => {
+        const { cp } = await import("node:fs/promises");
+        await cp(source, dest, { recursive: true });
+        await rm3(source, { recursive: true, force: true });
+      });
+    }
+    await rm3(pendingDir, { recursive: true, force: true });
+  } catch (error51) {
+    if (error51.code === "ENOENT") {
+      return;
+    }
+    throw error51;
+  }
+}
+async function cleanupPendingWiki(instance) {
+  const pendingDir = getWikiPendingDir(instance);
+  await rm3(pendingDir, { recursive: true, force: true });
+}
+function emitInstanceEvent(event, instance) {
+  eventBus.emit(event, {
+    squadId: instance.squadId,
+    instanceId: instance.id,
+    status: instance.status,
+    branch: instance.branch,
+    objectiveId: instance.objectiveId
+  });
+}
+var init_instances2 = __esm({
+  "packages/daemon/src/execution/instances.ts"() {
+    "use strict";
+    init_dist();
+    init_paths();
+    init_config();
+    init_event_bus();
+    init_store2();
+    init_worktree();
+  }
+});
+
 // packages/daemon/src/api/routes/squads.ts
 async function listObjectivesForSquad(squadId) {
   const database = await getDatabase();
@@ -52070,13 +52592,28 @@ function parseRepoInfo(repoUrl, repoOwner, repoName) {
 function isValidationError2(error51) {
   return error51 instanceof Error && /repoUrl|config|Invalid URL/i.test(error51.message);
 }
+async function getTasksForInstance(objectiveId) {
+  const database = await getDatabase();
+  const result = await database.execute({
+    sql: "SELECT id, title, assignee_id, status FROM tasks WHERE objective_id = ? ORDER BY created_at ASC",
+    args: [objectiveId]
+  });
+  return result.rows.map((row) => ({
+    id: asString(row.id),
+    description: asString(row.title),
+    assignedTo: asNullableString(row.assignee_id) ?? "unassigned",
+    status: asString(row.status)
+  }));
+}
 var import_express7, router7, DEFAULT_CONFIG;
 var init_squads2 = __esm({
   "packages/daemon/src/api/routes/squads.ts"() {
     "use strict";
     init_dist();
     import_express7 = __toESM(require_express2(), 1);
+    init_config();
     init_event_bus();
+    init_instances2();
     init_db();
     init_store2();
     router7 = (0, import_express7.Router)();
@@ -52087,7 +52624,23 @@ var init_squads2 = __esm({
     };
     router7.get("/api/squads", async (_req, res) => {
       try {
-        res.status(200).json(await listSquads());
+        const squads = await listSquads();
+        const config2 = loadConfig();
+        const enriched = await Promise.all(
+          squads.map(async (squad) => {
+            const instances = await listActiveInstances(squad.id);
+            const allInstances = await listInstancesBySquad(squad.id);
+            const members = await getMembers(squad.id);
+            return {
+              ...squad,
+              memberCount: members.length,
+              activeInstances: instances.filter((i) => i.status === "running").length,
+              totalInstances: allInstances.length,
+              recentActivity: []
+            };
+          })
+        );
+        res.status(200).json({ squads: enriched, config: { maxInstancesPerSquad: config2.maxInstancesPerSquad } });
       } catch (error51) {
         res.status(500).json({
           error: "Failed to list squads",
@@ -52102,7 +52655,21 @@ var init_squads2 = __esm({
           res.status(404).json({ error: "Squad not found" });
           return;
         }
-        res.status(200).json(squad);
+        const members = await getMembers(squad.id);
+        const instances = await listActiveInstances(squad.id);
+        const instanceSummaries = instances.map((inst) => ({
+          id: inst.id,
+          status: inst.status,
+          issueRef: null,
+          branch: inst.branch,
+          taskCount: 0,
+          tasksComplete: 0
+        }));
+        res.status(200).json({
+          squad,
+          members,
+          instances: instanceSummaries
+        });
       } catch (error51) {
         res.status(500).json({
           error: "Failed to fetch squad",
@@ -52275,13 +52842,65 @@ var init_squads2 = __esm({
         });
       }
     });
+    router7.get("/api/squads/:name/instances/:instanceId", async (req, res) => {
+      try {
+        const instance = await getInstance(req.params.instanceId);
+        if (!instance) {
+          res.status(404).json({ error: "Instance not found" });
+          return;
+        }
+        const squad = await getSquad(instance.squadId);
+        const members = squad ? await getMembers(squad.id) : [];
+        const tasks = instance.objectiveId ? await getTasksForInstance(instance.objectiveId) : [];
+        res.status(200).json({
+          squadColor: squad?.color ?? void 0,
+          instance: {
+            id: instance.id,
+            status: instance.status,
+            branch: instance.branch,
+            issueRef: null,
+            taskCount: tasks.length,
+            tasksComplete: tasks.filter((t) => t.status === "completed").length,
+            tasks,
+            meetingLog: []
+          },
+          members: members.map((m) => ({
+            id: m.id,
+            name: m.name,
+            role: m.role,
+            displayName: m.name,
+            veto: false,
+            status: "idle",
+            currentTask: null
+          })),
+          activity: []
+        });
+      } catch (error51) {
+        res.status(500).json({
+          error: "Failed to get instance",
+          details: error51 instanceof Error ? error51.message : "Unknown error"
+        });
+      }
+    });
+    router7.post("/api/squads/:name/instances/:instanceId/cancel", async (req, res) => {
+      try {
+        const instance = await cancelInstance(req.params.instanceId);
+        res.status(200).json({ instance });
+      } catch (error51) {
+        res.status(500).json({
+          error: "Failed to cancel instance",
+          details: error51 instanceof Error ? error51.message : "Unknown error"
+        });
+      }
+    });
   }
 });
 
 // packages/daemon/src/api/routes/usage.ts
 function getUsageParams(query) {
+  const since = typeof query.since === "string" ? query.since : void 0;
   return {
-    startDate: typeof query.startDate === "string" ? query.startDate : void 0,
+    startDate: typeof query.startDate === "string" ? query.startDate : since,
     endDate: typeof query.endDate === "string" ? query.endDate : void 0,
     squadId: typeof query.squadId === "string" ? query.squadId : void 0,
     agentId: typeof query.agentId === "string" ? query.agentId : void 0,
@@ -52298,11 +52917,11 @@ var init_usage = __esm({
     router8.get("/api/usage", async (req, res) => {
       try {
         const params = getUsageParams(req.query);
-        const summary = await getUsageSummary(params);
-        res.status(200).json(summary);
+        const result = await getUsageRecords(params);
+        res.status(200).json(result);
       } catch (error51) {
         res.status(500).json({
-          error: "Failed to fetch usage summary",
+          error: "Failed to fetch usage",
           details: error51 instanceof Error ? error51.message : "Unknown error"
         });
       }
@@ -55810,8 +56429,8 @@ var require_gray_matter = __commonJS({
 });
 
 // packages/daemon/src/wiki/wiki.ts
-import { mkdir as mkdir4, readFile as readFile3, readdir, rm as rm2, stat, writeFile as writeFile3 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname3, extname as extname2, join as join4, relative, resolve } from "node:path";
+import { mkdir as mkdir6, readFile as readFile3, readdir as readdir2, rm as rm4, stat, writeFile as writeFile3 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname3, extname as extname2, join as join6, relative, resolve } from "node:path";
 function getWikiPagesDir() {
   return wikiDirectoryOverride ?? process.env.WIKI_DIR ?? WIKI_DIR;
 }
@@ -55820,6 +56439,29 @@ async function listPages() {
   const pages = await Promise.all(markdownFiles.map((filePath) => readWikiPageFromFile(filePath)));
   return pages.sort((left, right) => left.path.localeCompare(right.path));
 }
+async function listDirectories() {
+  const directories = await collectDirectories(getWikiPagesDir());
+  return directories.map((dirPath) => ({ path: relative(getWikiPagesDir(), dirPath).replace(/\\/g, "/") })).sort((left, right) => left.path.localeCompare(right.path));
+}
+async function collectDirectories(directory) {
+  try {
+    const entries = await readdir2(directory, { withFileTypes: true });
+    const dirs = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const entryPath = join6(directory, entry.name);
+        dirs.push(entryPath);
+        dirs.push(...await collectDirectories(entryPath));
+      }
+    }
+    return dirs;
+  } catch (error51) {
+    if (isMissingFileError3(error51)) {
+      return [];
+    }
+    throw error51;
+  }
+}
 async function getPage(pagePath) {
   try {
     return await readWikiPageFromFile(resolvePagePath(pagePath));
@@ -55833,7 +56475,7 @@ async function getPage(pagePath) {
 async function createPage(pagePath, title, content, tags = []) {
   const filePath = resolvePagePath(pagePath);
   const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await mkdir4(dirname3(filePath), { recursive: true });
+  await mkdir6(dirname3(filePath), { recursive: true });
   await writeFile3(filePath, serializeWikiPage({ title, tags, updatedAt }, content), { flag: "wx" });
   return {
     path: toRelativePagePath(filePath),
@@ -55865,14 +56507,14 @@ async function updatePage(pagePath, updates) {
   return nextPage;
 }
 async function deletePage(pagePath) {
-  await rm2(resolvePagePath(pagePath), { force: true });
+  await rm4(resolvePagePath(pagePath), { force: true });
 }
 async function collectMarkdownFiles(directory) {
   try {
-    const entries = await readdir(directory, { withFileTypes: true });
+    const entries = await readdir2(directory, { withFileTypes: true });
     const files = [];
     for (const entry of entries) {
-      const entryPath = join4(directory, entry.name);
+      const entryPath = join6(directory, entry.name);
       if (entry.isDirectory()) {
         files.push(...await collectMarkdownFiles(entryPath));
         continue;
@@ -56100,8 +56742,16 @@ var init_wiki3 = __esm({
     router9 = (0, import_express9.Router)();
     router9.get("/api/wiki/pages", async (_req, res) => {
       try {
-        const pages = await listPages();
-        res.status(200).json(pages);
+        const [pages, directories] = await Promise.all([listPages(), listDirectories()]);
+        const dirEntries = directories.map((d) => ({
+          path: d.path,
+          title: d.path.split("/").pop() ?? d.path,
+          tags: [],
+          content: "",
+          updatedAt: "",
+          isDir: true
+        }));
+        res.status(200).json([...dirEntries, ...pages]);
       } catch (error51) {
         res.status(500).json({
           error: "Failed to list wiki pages",
@@ -60051,7 +60701,7 @@ var init_websocket = __esm({
 // packages/daemon/src/api/server.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { createServer } from "node:http";
-import { dirname as dirname4, join as join5, resolve as resolve2 } from "node:path";
+import { dirname as dirname4, join as join7, resolve as resolve2 } from "node:path";
 import { fileURLToPath } from "node:url";
 function createApiServer(config2) {
   const app = (0, import_express10.default)();
@@ -60074,6 +60724,9 @@ function createApiServer(config2) {
       supabaseAnonKey: config2.supabaseAnonKey ?? null
     });
   });
+  app.get("/api/version", (_req, res) => {
+    res.json({ version: APP_VERSION });
+  });
   app.use("/api", createAuthMiddleware(config2));
   app.use(router2);
   app.use(router7);
@@ -60084,13 +60737,16 @@ function createApiServer(config2) {
   app.use(router8);
   app.use(router5);
   app.use(router);
+  app.get("/api/config", (_req, res) => {
+    res.json({ config: { maxInstancesPerSquad: config2.maxInstancesPerSquad } });
+  });
   app.use("/api", (_req, res) => {
     res.status(404).json({ error: "API route not found" });
   });
   if (existsSync2(webDirectory)) {
     app.use(import_express10.default.static(webDirectory));
     app.use((_req, res) => {
-      res.sendFile(join5(webDirectory, "index.html"));
+      res.sendFile(join7(webDirectory, "index.html"));
     });
   }
   app.use((error51, _req, res, next) => {
@@ -61431,7 +62087,7 @@ var require_sonic_boom = __commonJS({
       if (!(this instanceof SonicBoom)) {
         return new SonicBoom(opts);
       }
-      let { fd, dest, minLength, maxLength, maxWrite, periodicFlush, sync, append = true, mkdir: mkdir9, retryEAGAIN, fsync, contentMode, mode } = opts || {};
+      let { fd, dest, minLength, maxLength, maxWrite, periodicFlush, sync, append = true, mkdir: mkdir10, retryEAGAIN, fsync, contentMode, mode } = opts || {};
       fd = fd || dest;
       this._len = 0;
       this.fd = -1;
@@ -61456,7 +62112,7 @@ var require_sonic_boom = __commonJS({
       this.append = append || false;
       this.mode = mode;
       this.retryEAGAIN = retryEAGAIN || (() => true);
-      this.mkdir = mkdir9 || false;
+      this.mkdir = mkdir10 || false;
       let fsWriteSync;
       let fsWrite;
       if (contentMode === kContentModeBuffer) {
@@ -62174,7 +62830,7 @@ var require_thread_stream = __commonJS({
     var { version: version2 } = require_package();
     var { EventEmitter: EventEmitter2 } = __require("events");
     var { Worker } = __require("worker_threads");
-    var { join: join15 } = __require("path");
+    var { join: join16 } = __require("path");
     var { pathToFileURL: pathToFileURL2 } = __require("url");
     var { wait } = require_wait();
     var {
@@ -62217,7 +62873,7 @@ var require_thread_stream = __commonJS({
     function createWorker(stream, opts) {
       const { filename, workerData } = opts;
       const bundlerOverrides = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
-      const toExecute = bundlerOverrides["thread-stream-worker"] || join15(__dirname, "lib", "worker.js");
+      const toExecute = bundlerOverrides["thread-stream-worker"] || join16(__dirname, "lib", "worker.js");
       const worker = new Worker(toExecute, {
         ...opts.workerOpts,
         trackUnmanagedFds: false,
@@ -62620,7 +63276,7 @@ var require_transport = __commonJS({
     "use strict";
     var { createRequire } = __require("module");
     var getCallers = require_caller();
-    var { join: join15, isAbsolute: isAbsolute2, sep } = __require("node:path");
+    var { join: join16, isAbsolute: isAbsolute2, sep } = __require("node:path");
     var sleep = require_atomic_sleep();
     var onExit = require_on_exit_leak_free();
     var ThreadStream = require_thread_stream();
@@ -62683,7 +63339,7 @@ var require_transport = __commonJS({
         throw new Error("only one of target or targets can be specified");
       }
       if (targets) {
-        target = bundlerOverrides["pino-worker"] || join15(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join16(__dirname, "worker.js");
         options2.targets = targets.filter((dest) => dest.target).map((dest) => {
           return {
             ...dest,
@@ -62701,7 +63357,7 @@ var require_transport = __commonJS({
           });
         });
       } else if (pipeline) {
-        target = bundlerOverrides["pino-worker"] || join15(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join16(__dirname, "worker.js");
         options2.pipelines = [pipeline.map((dest) => {
           return {
             ...dest,
@@ -62723,7 +63379,7 @@ var require_transport = __commonJS({
           return origin;
         }
         if (origin === "pino/file") {
-          return join15(__dirname, "..", "file.js");
+          return join16(__dirname, "..", "file.js");
         }
         let fixTarget2;
         for (const filePath of callers) {
@@ -63712,7 +64368,7 @@ var require_safe_stable_stringify = __commonJS({
               return circularValue;
             }
             let res = "";
-            let join15 = ",";
+            let join16 = ",";
             const originalIndentation = indentation;
             if (Array.isArray(value)) {
               if (value.length === 0) {
@@ -63726,7 +64382,7 @@ var require_safe_stable_stringify = __commonJS({
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join15 = `,
+                join16 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -63734,13 +64390,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join15;
+                res += join16;
               }
               const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join15}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join16}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -63761,7 +64417,7 @@ ${originalIndentation}`;
             let separator = "";
             if (spacer !== "") {
               indentation += spacer;
-              join15 = `,
+              join16 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -63775,13 +64431,13 @@ ${indentation}`;
               const tmp = stringifyFnReplacer(key2, value, stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join15;
+                separator = join16;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
-              separator = join15;
+              separator = join16;
             }
             if (spacer !== "" && separator.length > 1) {
               res = `
@@ -63822,7 +64478,7 @@ ${originalIndentation}`;
             }
             const originalIndentation = indentation;
             let res = "";
-            let join15 = ",";
+            let join16 = ",";
             if (Array.isArray(value)) {
               if (value.length === 0) {
                 return "[]";
@@ -63835,7 +64491,7 @@ ${originalIndentation}`;
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join15 = `,
+                join16 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -63843,13 +64499,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join15;
+                res += join16;
               }
               const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join15}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join16}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -63862,7 +64518,7 @@ ${originalIndentation}`;
             let whitespace = "";
             if (spacer !== "") {
               indentation += spacer;
-              join15 = `,
+              join16 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -63871,7 +64527,7 @@ ${indentation}`;
               const tmp = stringifyArrayReplacer(key2, value[key2], stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join15;
+                separator = join16;
               }
             }
             if (spacer !== "" && separator.length > 1) {
@@ -63929,20 +64585,20 @@ ${originalIndentation}`;
               indentation += spacer;
               let res2 = `
 ${indentation}`;
-              const join16 = `,
+              const join17 = `,
 ${indentation}`;
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
               let i = 0;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyIndent(String(i), value[i], stack, spacer, indentation);
                 res2 += tmp2 !== void 0 ? tmp2 : "null";
-                res2 += join16;
+                res2 += join17;
               }
               const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
               res2 += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res2 += `${join16}"... ${getItemCount(removedKeys)} not stringified"`;
+                res2 += `${join17}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               res2 += `
 ${originalIndentation}`;
@@ -63958,16 +64614,16 @@ ${originalIndentation}`;
               return '"[Object]"';
             }
             indentation += spacer;
-            const join15 = `,
+            const join16 = `,
 ${indentation}`;
             let res = "";
             let separator = "";
             let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
             if (isTypedArrayWithEntries(value)) {
-              res += stringifyTypedArray(value, join15, maximumBreadth);
+              res += stringifyTypedArray(value, join16, maximumBreadth);
               keys = keys.slice(value.length);
               maximumPropertiesToStringify -= value.length;
-              separator = join15;
+              separator = join16;
             }
             if (deterministic) {
               keys = sort(keys, comparator);
@@ -63978,13 +64634,13 @@ ${indentation}`;
               const tmp = stringifyIndent(key2, value[key2], stack, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}: ${tmp}`;
-                separator = join15;
+                separator = join16;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
-              separator = join15;
+              separator = join16;
             }
             if (separator !== "") {
               res = `
@@ -67014,7 +67670,7 @@ var require_pino_pretty = __commonJS({
 });
 
 // packages/daemon/src/logging/logger.ts
-import { join as join6 } from "node:path";
+import { join as join8 } from "node:path";
 function shouldPrettyPrint(logLevel) {
   return process.env.NODE_ENV !== "production" || process.env.LOG_LEVEL === "debug" || logLevel === "debug" || logLevel === "trace";
 }
@@ -67061,7 +67717,7 @@ var init_logger = __esm({
     init_paths();
     import_pino = __toESM(require_pino(), 1);
     import_pino_pretty = __toESM(require_pino_pretty(), 1);
-    LOG_FILE_PATH = join6(LOGS_DIR, "io.log");
+    LOG_FILE_PATH = join8(LOGS_DIR, "io.log");
     rootLogger = null;
   }
 });
@@ -67659,7 +68315,7 @@ var init_reset = __esm({
 // packages/daemon/src/copilot/client.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { mkdirSync as mkdirSync2 } from "node:fs";
-import { join as join7 } from "node:path";
+import { join as join9 } from "node:path";
 import { CopilotClient } from "@github/copilot-sdk";
 function readTokenFromEnvironment() {
   const token = process.env.GITHUB_TOKEN?.trim();
@@ -67745,7 +68401,7 @@ var init_client = __esm({
     "use strict";
     init_paths();
     COPILOT_AUTH_ERROR_HINT = "Set GITHUB_TOKEN or authenticate with the GitHub CLI (`gh auth login`) so `gh auth token` returns a valid token.";
-    COPILOT_BASE_DIRECTORY = join7(DATA_DIR, "copilot-sdk");
+    COPILOT_BASE_DIRECTORY = join9(DATA_DIR, "copilot-sdk");
     copilotClientSingleton = null;
     copilotClientInitPromise = null;
   }
@@ -67904,8 +68560,8 @@ var init_session = __esm({
 });
 
 // packages/daemon/src/skills/loader.ts
-import { readFile as readFile4, readdir as readdir2 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname5, join as join8 } from "node:path";
+import { readFile as readFile4, readdir as readdir3 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname5, join as join10 } from "node:path";
 async function scanSkills() {
   const skillFilePaths = await collectSkillFiles(SKILLS_DIR);
   const skills = await Promise.all(skillFilePaths.map((filePath) => readSkillFromFile(filePath)));
@@ -67913,10 +68569,10 @@ async function scanSkills() {
 }
 async function collectSkillFiles(directory) {
   try {
-    const entries = await readdir2(directory, { withFileTypes: true });
+    const entries = await readdir3(directory, { withFileTypes: true });
     const skillFiles = [];
     for (const entry of entries) {
-      const entryPath = join8(directory, entry.name);
+      const entryPath = join10(directory, entry.name);
       if (entry.isDirectory()) {
         skillFiles.push(...await collectSkillFiles(entryPath));
         continue;
@@ -67959,8 +68615,8 @@ var init_loader = __esm({
 });
 
 // packages/daemon/src/skills/manager.ts
-import { mkdir as mkdir5, readFile as readFile5, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
-import { basename as basename4, dirname as dirname6, join as join9 } from "node:path";
+import { mkdir as mkdir7, readFile as readFile5, rm as rm5, writeFile as writeFile4 } from "node:fs/promises";
+import { basename as basename4, dirname as dirname6, join as join11 } from "node:path";
 async function installSkill2(url2) {
   const response = await fetch(url2);
   if (!response.ok) {
@@ -67970,8 +68626,8 @@ async function installSkill2(url2) {
   }
   const skillMarkdown = await response.text();
   const skillId = getSkillIdFromUrl(url2);
-  const skillDirectory = join9(SKILLS_DIR, skillId);
-  const skillPath = join9(skillDirectory, "SKILL.md");
+  const skillDirectory = join11(SKILLS_DIR, skillId);
+  const skillPath = join11(skillDirectory, "SKILL.md");
   const parsed = (0, import_gray_matter3.default)(skillMarkdown);
   const installedSkill = {
     id: skillId,
@@ -67979,13 +68635,13 @@ async function installSkill2(url2) {
     url: url2,
     installedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await mkdir5(skillDirectory, { recursive: true });
+  await mkdir7(skillDirectory, { recursive: true });
   await writeFile4(skillPath, skillMarkdown, "utf8");
   await upsertInstalledSkill(installedSkill);
   return installedSkill;
 }
 async function removeSkill2(id) {
-  await rm3(join9(SKILLS_DIR, id), { recursive: true, force: true });
+  await rm5(join11(SKILLS_DIR, id), { recursive: true, force: true });
   const lockFile = await readSkillsLock();
   lockFile.skills = lockFile.skills.filter((skill) => skill.id !== id);
   await writeSkillsLock2(lockFile);
@@ -68014,7 +68670,7 @@ async function readSkillsLock() {
   }
 }
 async function writeSkillsLock2(lockFile) {
-  await mkdir5(dirname6(SKILLS_LOCK_PATH), { recursive: true });
+  await mkdir7(dirname6(SKILLS_LOCK_PATH), { recursive: true });
   await writeFile4(SKILLS_LOCK_PATH, `${JSON.stringify(lockFile, null, 2)}
 `, "utf8");
 }
@@ -68104,10 +68760,10 @@ var init_skills2 = __esm({
 });
 
 // packages/daemon/src/orchestrator/tools/coding.ts
-import { exec } from "node:child_process";
-import { mkdir as mkdir6, readFile as readFile6, readdir as readdir3, stat as stat2, writeFile as writeFile5 } from "node:fs/promises";
+import { exec as exec2 } from "node:child_process";
+import { mkdir as mkdir8, readFile as readFile6, readdir as readdir4, stat as stat2, writeFile as writeFile5 } from "node:fs/promises";
 import { dirname as dirname7, relative as relative2, resolve as resolve3 } from "node:path";
-import { promisify } from "node:util";
+import { promisify as promisify2 } from "node:util";
 function resolveWorkspacePath(inputPath = ".") {
   const resolvedPath = resolve3(DEFAULT_ROOT, inputPath);
   const relativePath = relative2(DEFAULT_ROOT, resolvedPath);
@@ -68121,7 +68777,7 @@ function globToRegExp(pattern) {
   return new RegExp(`^${source}$`, "iu");
 }
 async function walkFiles(directory) {
-  const entries = await readdir3(directory, { withFileTypes: true });
+  const entries = await readdir4(directory, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     const entryPath = resolve3(directory, entry.name);
@@ -68145,12 +68801,12 @@ async function collectMatchingFiles(basePath, pattern) {
     (filePath) => matcher.test(relative2(basePath, filePath).replace(/\\/gu, "/"))
   );
 }
-var execAsync, DEFAULT_ROOT, readFileSchema, editFileSchema, runCommandSchema, searchCodeSchema, listFilesSchema, codingToolDefinitions, executeCodingToolCall;
+var execAsync2, DEFAULT_ROOT, readFileSchema, editFileSchema, runCommandSchema, searchCodeSchema, listFilesSchema, codingToolDefinitions, executeCodingToolCall;
 var init_coding = __esm({
   "packages/daemon/src/orchestrator/tools/coding.ts"() {
     "use strict";
     init_zod();
-    execAsync = promisify(exec);
+    execAsync2 = promisify2(exec2);
     DEFAULT_ROOT = process.cwd();
     readFileSchema = external_exports.object({
       path: external_exports.string().trim().min(1)
@@ -68215,14 +68871,14 @@ var init_coding = __esm({
         case "edit_file": {
           const { path, content } = editFileSchema.parse(rawArgs);
           const filePath = resolveWorkspacePath(path);
-          await mkdir6(dirname7(filePath), { recursive: true });
+          await mkdir8(dirname7(filePath), { recursive: true });
           await writeFile5(filePath, content, "utf8");
           return { message: `Wrote ${filePath}.`, path: filePath };
         }
         case "run_command": {
           const { command, cwd } = runCommandSchema.parse(rawArgs);
           const workingDirectory = cwd ? resolveWorkspacePath(cwd) : DEFAULT_ROOT;
-          const { stdout, stderr } = await execAsync(command, {
+          const { stdout, stderr } = await execAsync2(command, {
             cwd: workingDirectory,
             maxBuffer: 1024 * 1024 * 4,
             timeout: 12e4
@@ -68241,7 +68897,7 @@ var init_coding = __esm({
           if (glob) {
             args.unshift("--glob", glob);
           }
-          const { stdout } = await execAsync(
+          const { stdout } = await execAsync2(
             `rg ${args.map((value) => JSON.stringify(value)).join(" ")}`,
             {
               cwd: DEFAULT_ROOT,
@@ -68595,10 +69251,10 @@ var init_history = __esm({
 });
 
 // packages/daemon/src/execution/agent.ts
-import { exec as exec2 } from "node:child_process";
-import { mkdir as mkdir7, readFile as readFile7, readdir as readdir4, stat as stat3, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname8, extname as extname3, isAbsolute, join as join10, relative as relative3, resolve as resolve4 } from "node:path";
-import { promisify as promisify2 } from "node:util";
+import { exec as exec3 } from "node:child_process";
+import { mkdir as mkdir9, readFile as readFile7, readdir as readdir5, stat as stat3, writeFile as writeFile6 } from "node:fs/promises";
+import { dirname as dirname8, extname as extname3, isAbsolute, join as join12, relative as relative3, resolve as resolve4 } from "node:path";
+import { promisify as promisify3 } from "node:util";
 import {
   CopilotClient as CopilotClient2,
   approveAll as approveAll2,
@@ -68658,12 +69314,12 @@ function ensureWithinWorktree(worktreePath, requestedPath) {
   return candidate;
 }
 async function collectFiles(directory, recursive, output2) {
-  const entries = await readdir4(directory, { withFileTypes: true });
+  const entries = await readdir5(directory, { withFileTypes: true });
   for (const entry of entries) {
     if (output2.length >= MAX_LIST_RESULTS) {
       return;
     }
-    const fullPath = join10(directory, entry.name);
+    const fullPath = join12(directory, entry.name);
     output2.push(fullPath);
     if (recursive && entry.isDirectory()) {
       await collectFiles(fullPath, recursive, output2);
@@ -68723,7 +69379,7 @@ function createAgentToolSet(worktreePath) {
     skipPermission: true,
     handler: async (args) => {
       const targetPath = ensureWithinWorktree(worktreePath, args.path);
-      await mkdir7(dirname8(targetPath), { recursive: true });
+      await mkdir9(dirname8(targetPath), { recursive: true });
       let nextContent = args.content ?? "";
       let previousContent = "";
       try {
@@ -68759,7 +69415,7 @@ function createAgentToolSet(worktreePath) {
     },
     skipPermission: true,
     handler: async (args) => {
-      const { stdout, stderr } = await execAsync2(args.command, {
+      const { stdout, stderr } = await execAsync3(args.command, {
         cwd: worktreePath,
         timeout: Math.max(1e3, Math.min(args.timeoutMs ?? 6e4, 3e5)),
         maxBuffer: 10 * 1024 * 1024
@@ -68874,7 +69530,7 @@ async function executeAgentTask(member, task, worktreePath, options2) {
 Recent agent history:
 ${historyContext}
 
-${mcpServerNote}`
+${mcpServerNote}${options2?.instancePromptSuffix ?? ""}`
       }
     });
     session.on("assistant.usage", (event) => {
@@ -68915,7 +69571,7 @@ Work only inside the current worktree. Summarize the concrete changes you made,
     }
   }
 }
-var execAsync2, MAX_FILE_SIZE, MAX_LIST_RESULTS, MAX_SEARCH_RESULTS;
+var execAsync3, MAX_FILE_SIZE, MAX_LIST_RESULTS, MAX_SEARCH_RESULTS;
 var init_agent = __esm({
   "packages/daemon/src/execution/agent.ts"() {
     "use strict";
@@ -68923,13 +69579,46 @@ var init_agent = __esm({
     init_registry();
     init_store2();
     init_history();
-    execAsync2 = promisify2(exec2);
+    execAsync3 = promisify3(exec3);
     MAX_FILE_SIZE = 2e5;
     MAX_LIST_RESULTS = 200;
     MAX_SEARCH_RESULTS = 100;
   }
 });
 
+// packages/daemon/src/execution/instance-context.ts
+async function buildWikiContext(_squadId) {
+  const pages = await listPages().catch(() => []);
+  if (pages.length === 0) {
+    return "No wiki pages available.";
+  }
+  const entries = pages.map((page) => {
+    const summary = page.content.slice(0, 150).replace(/\n/g, " ").trim();
+    const truncated = summary.length < page.content.length ? `${summary}...` : summary;
+    return `- **${page.title}** (${page.path}): ${truncated}`;
+  });
+  return `## Squad Wiki Knowledge (${pages.length} pages)
+
+${entries.join("\n")}`;
+}
+async function buildInstanceSystemPromptSuffix(squadId, instanceId) {
+  const wikiContext = await buildWikiContext(squadId);
+  return [
+    "\n\n--- Instance Context ---",
+    `Instance ID: ${instanceId}`,
+    "You are working within an isolated instance. Your changes will be reviewed before merging.",
+    "Wiki pages written during this instance go to a pending area and merge on successful completion.",
+    "",
+    wikiContext
+  ].join("\n");
+}
+var init_instance_context = __esm({
+  "packages/daemon/src/execution/instance-context.ts"() {
+    "use strict";
+    init_wiki();
+  }
+});
+
 // packages/daemon/src/squad/roles.ts
 function generateRolePrompt(role, repoContext) {
   const normalizedRole = role.trim() || "specialist";
@@ -69018,10 +69707,10 @@ Return strict JSON in this shape:
 });
 
 // packages/daemon/src/execution/planning.ts
-import { exec as exec3 } from "node:child_process";
+import { exec as exec4 } from "node:child_process";
 import { access, readFile as readFile8 } from "node:fs/promises";
-import { join as join11 } from "node:path";
-import { promisify as promisify3 } from "node:util";
+import { join as join13 } from "node:path";
+import { promisify as promisify4 } from "node:util";
 import { CopilotClient as CopilotClient3, approveAll as approveAll3 } from "@github/copilot-sdk";
 async function fileExists(path) {
   try {
@@ -69033,13 +69722,13 @@ async function fileExists(path) {
 }
 async function buildRepoContext(repoPath) {
   for (const candidate of README_CANDIDATES) {
-    const readmePath = join11(repoPath, candidate);
+    const readmePath = join13(repoPath, candidate);
     if (await fileExists(readmePath)) {
       const content = await readFile8(readmePath, "utf8");
       return content.slice(0, MAX_REPO_CONTEXT_LENGTH);
     }
   }
-  const { stdout } = await execAsync3("git ls-files", {
+  const { stdout } = await execAsync4("git ls-files", {
     cwd: repoPath,
     maxBuffer: 5 * 1024 * 1024
   });
@@ -69152,150 +69841,22 @@ ${repoContext}`
     }
   }
 }
-var execAsync3, README_CANDIDATES, MAX_REPO_CONTEXT_LENGTH;
+var execAsync4, README_CANDIDATES, MAX_REPO_CONTEXT_LENGTH;
 var init_planning = __esm({
   "packages/daemon/src/execution/planning.ts"() {
     "use strict";
     init_dist();
     init_roles();
-    execAsync3 = promisify3(exec3);
+    execAsync4 = promisify4(exec4);
     README_CANDIDATES = ["README.md", "readme.md"];
     MAX_REPO_CONTEXT_LENGTH = 8e3;
   }
 });
 
-// packages/daemon/src/execution/worktree.ts
-import { exec as exec4 } from "node:child_process";
-import { mkdir as mkdir8, rm as rm4 } from "node:fs/promises";
-import { join as join12 } from "node:path";
-import { promisify as promisify4 } from "node:util";
-function sanitizeBranchName(branchName) {
-  return branchName.replace(/[^a-zA-Z0-9._-]+/g, "-");
-}
-async function runGit(command, cwd) {
-  const { stdout } = await execAsync4(command, {
-    cwd,
-    ...EXEC_OPTIONS
-  });
-  return stdout.trim();
-}
-async function branchExists(repoPath, branchName) {
-  const output2 = await runGit(`git branch --list ${JSON.stringify(branchName)}`, repoPath);
-  return output2.length > 0;
-}
-function getWorktreePath(repoPath, branchName) {
-  return join12(repoPath, ".worktrees", sanitizeBranchName(branchName));
-}
-async function listWorktrees(repoPath) {
-  const output2 = await runGit("git worktree list --porcelain", repoPath);
-  if (!output2) {
-    return [];
-  }
-  const blocks = output2.split(/\r?\n\r?\n/).filter(Boolean);
-  return blocks.map((block) => {
-    const info = {
-      path: "",
-      branch: null,
-      head: null,
-      bare: false,
-      detached: false,
-      locked: false,
-      prunable: false
-    };
-    for (const line of block.split(/\r?\n/)) {
-      const [key, ...rest] = line.split(" ");
-      const value = rest.join(" ").trim();
-      switch (key) {
-        case "worktree":
-          info.path = value;
-          break;
-        case "branch":
-          info.branch = value.replace(/^refs\/heads\//, "");
-          break;
-        case "HEAD":
-          info.head = value;
-          break;
-        case "bare":
-          info.bare = true;
-          break;
-        case "detached":
-          info.detached = true;
-          break;
-        case "locked":
-          info.locked = true;
-          break;
-        case "prunable":
-          info.prunable = true;
-          break;
-      }
-    }
-    return info;
-  });
-}
-async function createWorktree(repoPath, branchName, baseBranch) {
-  const worktreePath = getWorktreePath(repoPath, branchName);
-  await mkdir8(join12(repoPath, ".worktrees"), { recursive: true });
-  const existing = (await listWorktrees(repoPath)).find(
-    (worktree) => worktree.path === worktreePath
-  );
-  if (existing) {
-    return worktreePath;
-  }
-  const startPoint = baseBranch?.trim();
-  const createNewBranch = !await branchExists(repoPath, branchName);
-  const command = createNewBranch ? `git worktree add ${JSON.stringify(worktreePath)} -b ${JSON.stringify(branchName)}${startPoint ? ` ${JSON.stringify(startPoint)}` : ""}` : `git worktree add ${JSON.stringify(worktreePath)} ${JSON.stringify(branchName)}`;
-  try {
-    await runGit(command, repoPath);
-    return worktreePath;
-  } catch (error51) {
-    const message2 = error51 instanceof Error ? error51.message : String(error51);
-    if (/already exists/i.test(message2)) {
-      return worktreePath;
-    }
-    throw new Error(`Failed to create worktree for ${branchName}: ${message2}`);
-  }
-}
-async function cleanupWorktree(worktreePath) {
-  const parentRepoPath = join12(worktreePath, "..", "..");
-  try {
-    await runGit(`git worktree remove ${JSON.stringify(worktreePath)}`, parentRepoPath);
-  } catch (error51) {
-    const message2 = error51 instanceof Error ? error51.message : String(error51);
-    if (!/not a working tree/i.test(message2) && !/does not exist/i.test(message2)) {
-      await runGit(
-        `git worktree remove --force ${JSON.stringify(worktreePath)}`,
-        parentRepoPath
-      ).catch(() => void 0);
-    }
-  }
-  await runGit("git worktree prune", parentRepoPath).catch(() => void 0);
-  await rm4(worktreePath, { recursive: true, force: true }).catch(() => void 0);
-}
-async function pushBranch(worktreePath, remote = DEFAULT_REMOTE) {
-  const branchName = await runGit("git branch --show-current", worktreePath);
-  if (!branchName) {
-    throw new Error(`Unable to determine branch for worktree ${worktreePath}`);
-  }
-  const output2 = await runGit(
-    `git push --set-upstream ${JSON.stringify(remote)} ${JSON.stringify(branchName)}`,
-    worktreePath
-  );
-  return { branchName, remote, output: output2 };
-}
-var execAsync4, DEFAULT_REMOTE, EXEC_OPTIONS;
-var init_worktree = __esm({
-  "packages/daemon/src/execution/worktree.ts"() {
-    "use strict";
-    execAsync4 = promisify4(exec4);
-    DEFAULT_REMOTE = "origin";
-    EXEC_OPTIONS = { maxBuffer: 10 * 1024 * 1024 };
-  }
-});
-
 // packages/daemon/src/execution/pr.ts
 import { exec as exec5 } from "node:child_process";
-import { rm as rm5, writeFile as writeFile7 } from "node:fs/promises";
-import { join as join13 } from "node:path";
+import { rm as rm6, writeFile as writeFile7 } from "node:fs/promises";
+import { join as join14 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 async function runCommand(command, cwd) {
   const { stdout } = await execAsync5(command, {
@@ -69309,7 +69870,7 @@ function extractUrl(output2) {
 }
 function buildBodyFilePath(repoPath, branchName) {
   const safeBranchName = branchName.replace(/[^a-zA-Z0-9._-]+/g, "-");
-  return join13(repoPath, `.io-pr-body-${safeBranchName}.md`);
+  return join14(repoPath, `.io-pr-body-${safeBranchName}.md`);
 }
 function buildPrBody(objective, plan, taskSummaries, qaOutcome) {
   const tasks = taskSummaries.map((summary) => `- ${summary}`).join("\n") || "- No task summaries recorded.";
@@ -69344,7 +69905,7 @@ async function createPullRequest(options2) {
       options2.repoPath
     );
   } finally {
-    await rm5(bodyFilePath, { force: true }).catch(() => void 0);
+    await rm6(bodyFilePath, { force: true }).catch(() => void 0);
   }
   const prUrl = extractUrl(createOutput);
   if (!prUrl) {
@@ -69642,7 +70203,7 @@ var init_tasks = __esm({
 // packages/daemon/src/execution/runner.ts
 import { exec as exec7 } from "node:child_process";
 import { access as access2 } from "node:fs/promises";
-import { basename as basename5, join as join14 } from "node:path";
+import { basename as basename5, join as join15 } from "node:path";
 import { promisify as promisify7 } from "node:util";
 async function pathExists(path) {
   try {
@@ -69662,12 +70223,12 @@ async function runGit2(command, cwd) {
 async function resolveRepoPath(repoUrl, repoName) {
   const candidates = [
     process.cwd(),
-    join14(process.cwd(), repoName),
-    join14(process.cwd(), "repos", repoName),
-    join14(process.cwd(), "..", repoName)
+    join15(process.cwd(), repoName),
+    join15(process.cwd(), "repos", repoName),
+    join15(process.cwd(), "..", repoName)
   ];
   for (const candidate of candidates) {
-    if (!await pathExists(join14(candidate, ".git"))) {
+    if (!await pathExists(join15(candidate, ".git"))) {
       continue;
     }
     const remoteUrl = await runGit2("git remote get-url origin", candidate).catch(() => "");
@@ -69695,7 +70256,7 @@ function summarizeTask(task, member) {
   const owner = member ? `${member.name} (${member.role})` : task.assigneeId ?? "unassigned";
   return `${task.title} \u2014 ${owner}: ${task.result ?? "No result recorded."}`;
 }
-async function executePendingTasks(objective, members, worktreePath, mcpServers) {
+async function executePendingTasks(objective, members, worktreePath, mcpServers, instancePromptSuffix) {
   const pendingTasks = await getNextPendingTasks(objective.id);
   if (pendingTasks.length === 0) {
     return getTasksForObjective(objective.id);
@@ -69727,7 +70288,10 @@ async function executePendingTasks(objective, members, worktreePath, mcpServers)
         agentId: member.id,
         taskId: task.id
       });
-      const execution = await executeAgentTask(member, task, worktreePath, { mcpServers });
+      const execution = await executeAgentTask(member, task, worktreePath, {
+        mcpServers,
+        instancePromptSuffix
+      });
       if (!execution.success) {
         const failedTask = await markTaskFailed(task.id, execution.result);
         eventBus.emit(EVENT_NAMES.TASK_FAILED, {
@@ -69762,7 +70326,7 @@ async function createFeedbackTask(objectiveId, teamLead, title, description) {
     status: "pending"
   });
 }
-async function executeObjective(squadId, objectiveId) {
+async function executeObjective(squadId, objectiveId, instanceContext) {
   const squadRecord = await getSquad(squadId);
   if (!squadRecord) {
     return { success: false, error: `Squad ${squadId} was not found.` };
@@ -69780,10 +70344,11 @@ async function executeObjective(squadId, objectiveId) {
   const teamLead = requireMemberByRole(squadRecord.members, "team-lead");
   const qaMember = requireMemberByRole(squadRecord.members, "qa");
   const repoPath = await resolveRepoPath(squadRecord.repoUrl, squadRecord.repoName);
-  const baseBranch = await runGit2("git branch --show-current", repoPath) || "main";
-  const branchName = buildBranchName(objectiveId);
-  let worktreePath = null;
+  const baseBranch = instanceContext ? instanceContext.branch.replace(/^squad\//, "") : await runGit2("git branch --show-current", repoPath) || "main";
+  const branchName = instanceContext?.branch ?? buildBranchName(objectiveId);
+  let worktreePath = instanceContext?.worktreePath ?? null;
   let currentObjective = objectiveRecord;
+  const ownsWorktree = !instanceContext;
   try {
     await updateSquad(squadId, { status: "executing" });
     const startedObjective = await updateObjectiveStatus(objectiveId, "planning");
@@ -69791,7 +70356,9 @@ async function executeObjective(squadId, objectiveId) {
       currentObjective = startedObjective;
     }
     eventBus.emit(EVENT_NAMES.OBJECTIVE_STARTED, { objective: currentObjective });
-    worktreePath = await createWorktree(repoPath, branchName, baseBranch);
+    if (!worktreePath) {
+      worktreePath = await createWorktree(repoPath, branchName, baseBranch);
+    }
     const objectiveWithBranch = await updateObjectiveBranch(objectiveId, branchName);
     if (objectiveWithBranch) {
       currentObjective = objectiveWithBranch;
@@ -69803,6 +70370,7 @@ async function executeObjective(squadId, objectiveId) {
     }
     await updateObjectiveStatus(objectiveId, "executing");
     await createTasksFromPlan(objectiveId, planned.tasks, squadRecord.members);
+    const instancePromptSuffix = instanceContext ? await buildInstanceSystemPromptSuffix(squadId, instanceContext.instanceId).catch(() => "") : void 0;
     let qaOutcome = null;
     while (true) {
       currentObjective = await getObjective(objectiveId) ?? currentObjective;
@@ -69810,7 +70378,8 @@ async function executeObjective(squadId, objectiveId) {
         currentObjective,
         squadRecord.members,
         worktreePath,
-        squadRecord.config.mcpServers
+        squadRecord.config.mcpServers,
+        instancePromptSuffix
       );
       const tasksAfterExecution = await getTasksForObjective(objectiveId);
       eventBus.emit(EVENT_NAMES.REVIEW_STARTED, { objectiveId });
@@ -69908,7 +70477,7 @@ ${reviewOutcome.issues?.join("\n") ?? "Resolve the review feedback and re-valida
     });
     return { success: false, error: message2 };
   } finally {
-    if (worktreePath) {
+    if (ownsWorktree && worktreePath) {
       await cleanupWorktree(worktreePath).catch(() => void 0);
     }
     await updateSquad(squadId, { status: "active" }).catch(() => null);
@@ -69924,6 +70493,7 @@ var init_runner = __esm({
     init_store2();
     init_agent();
     init_history();
+    init_instance_context();
     init_planning();
     init_pr();
     init_qa();
@@ -70191,6 +70761,42 @@ function formatSquadList(squads) {
     (squad) => `${squad.id}: ${squad.name} (${squad.repoOwner}/${squad.repoName}) [${squad.status}]`
   ).join("\n");
 }
+async function startAndExecuteInstance(instanceId, squad, objectiveId) {
+  try {
+    const repoPath = await resolveRepoPath(squad.repoUrl, squad.repoName);
+    const baseBranch = "main";
+    const started = await startInstance(instanceId, repoPath, baseBranch);
+    const result = await executeObjective(squad.id, objectiveId, {
+      instanceId: started.id,
+      worktreePath: started.worktreePath ?? "",
+      branch: started.branch ?? ""
+    });
+    if (result.success) {
+      await completeInstance(instanceId);
+    } else {
+      await failInstance(instanceId, result.error ?? "Unknown execution failure");
+    }
+  } catch (error51) {
+    const message2 = error51 instanceof Error ? error51.message : String(error51);
+    await failInstance(instanceId, message2).catch(() => {
+    });
+  } finally {
+    try {
+      const running = await countRunningInstances(squad.id);
+      const config2 = (await Promise.resolve().then(() => (init_config(), config_exports))).loadConfig();
+      if (running < config2.maxInstancesPerSquad) {
+        const next = await getNextQueued(squad.id);
+        if (next) {
+          const freshSquad = await getSquad(squad.id);
+          if (freshSquad) {
+            void startAndExecuteInstance(next.id, freshSquad, next.objectiveId);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+}
 function createSquadToolExecutor(config2) {
   return async (toolName, rawArgs) => {
     switch (toolName) {
@@ -70244,14 +70850,18 @@ function createSquadToolExecutor(config2) {
           throw new Error(`Squad ${squadId} was not found.`);
         }
         const createdObjective = await createObjective(squadId, objective);
-        void executeObjective(squadId, createdObjective.id).catch(async (error51) => {
-          const message2 = error51 instanceof Error ? error51.message : String(error51);
-          await updateSquad(squadId, { status: "active" }).catch(() => void 0);
-          console.error(`Failed to execute objective ${createdObjective.id}: ${message2}`);
+        const { instance, queued } = await spawnInstance({
+          squadId,
+          objectiveId: createdObjective.id
         });
+        if (!queued) {
+          void startAndExecuteInstance(instance.id, squad, createdObjective.id);
+        }
         return {
-          message: `Delegated objective to squad ${squad.name}. Execution started in the background.`,
-          objective: createdObjective
+          message: queued ? `Objective queued for squad ${squad.name} (at capacity). Instance ${instance.id} will start when a slot opens.` : `Delegated objective to squad ${squad.name}. Instance ${instance.id} started.`,
+          objective: createdObjective,
+          instanceId: instance.id,
+          queued
         };
       }
       default:
@@ -70265,6 +70875,7 @@ var init_squad2 = __esm({
     "use strict";
     init_dist();
     init_zod();
+    init_instances2();
     init_runner();
     init_hiring();
     init_manager2();