eminiar 0.11.0 → 0.12.0

package/dist/cli.js

@@ -2601,9 +2601,9 @@ function handleIntersectionResults(result, left, right) {
   result.value = merged.data;
   return result;
 }
-function getTupleOptStart(items, key) {
-  for (let i = items.length - 1; i >= 0; i--) {
-    const omittable = key === "optin" ? items[i]._zod.optin !== void 0 : items[i]._zod.optout === "optional";
+function getTupleOptStart(items2, key) {
+  for (let i = items2.length - 1; i >= 0; i--) {
+    const omittable = key === "optin" ? items2[i]._zod.optin !== void 0 : items2[i]._zod.optout === "optional";
     if (!omittable)
       return i + 1;
   }
@@ -2615,11 +2615,11 @@ function handleTupleResult(result, final, index) {
   }
   final.value[index] = result.value;
 }
-function handleTupleResults(itemResults, final, items, input2, optoutStart) {
-  for (let i = 0; i < items.length; i++) {
+function handleTupleResults(itemResults, final, items2, input2, optoutStart) {
+  for (let i = 0; i < items2.length; i++) {
     const r = itemResults[i];
     const isPresent = i < input2.length;
-    if (!isPresent && i >= optoutStart && items[i]._zod.optin === "optional") {
+    if (!isPresent && i >= optoutStart && items2[i]._zod.optin === "optional") {
       final.value.length = i;
       break;
     }
@@ -2633,7 +2633,7 @@ function handleTupleResults(itemResults, final, items, input2, optoutStart) {
     final.value[i] = r.value;
   }
   for (let i = final.value.length - 1; i >= input2.length; i--) {
-    if (items[i]._zod.optout === "optional" && final.value[i] === void 0) {
+    if (items2[i]._zod.optout === "optional" && final.value[i] === void 0) {
       final.value.length = i;
     } else {
       break;
@@ -3830,7 +3830,7 @@ var init_schemas = __esm({
     });
     $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
       $ZodType.init(inst, def);
-      const items = def.items;
+      const items2 = def.items;
       const memo2 = globalConfig.memoizer;
       memo2?.attach(inst);
       inst._zod.parse = (payload, ctx) => {
@@ -3846,8 +3846,8 @@ var init_schemas = __esm({
         }
         payload.value = memo2 ? memo2.alloc(inst, payload, [], ctx) : [];
         const proms = [];
-        const optinStart = getTupleOptStart(items, "optin");
-        const optoutStart = getTupleOptStart(items, "optout");
+        const optinStart = getTupleOptStart(items2, "optin");
+        const optoutStart = getTupleOptStart(items2, "optout");
         if (!def.rest) {
           if (input2.length < optinStart) {
             payload.issues.push({
@@ -3860,10 +3860,10 @@ var init_schemas = __esm({
             });
             return payload;
           }
-          if (input2.length > items.length) {
+          if (input2.length > items2.length) {
             payload.issues.push({
               code: "too_big",
-              maximum: items.length,
+              maximum: items2.length,
               inclusive: true,
               input: input2,
               inst,
@@ -3871,11 +3871,11 @@ var init_schemas = __esm({
             });
           }
         }
-        const itemResults = new Array(items.length);
+        const itemResults = new Array(items2.length);
         const abortEarly = def.rest ? ctx?.abortEarly : void 0;
         let itemAborted = false;
-        for (let i = 0; i < items.length; i++) {
-          const r = items[i]._zod.run({ value: input2[i], issues: [] }, ctx);
+        for (let i = 0; i < items2.length; i++) {
+          const r = items2[i]._zod.run({ value: input2[i], issues: [] }, ctx);
           if (r instanceof Promise) {
             proms.push(r.then((rr) => {
               itemResults[i] = rr;
@@ -3887,8 +3887,8 @@ var init_schemas = __esm({
           }
         }
         if (def.rest && !itemAborted) {
-          let i = items.length - 1;
-          const rest2 = input2.slice(items.length);
+          let i = items2.length - 1;
+          const rest2 = input2.slice(items2.length);
           let seen = payload.issues.length;
           for (const el of rest2) {
             if (abortEarly && payload.issues.length !== seen) {
@@ -3906,9 +3906,9 @@ var init_schemas = __esm({
           }
         }
         if (proms.length) {
-          return Promise.all(proms).then(() => handleTupleResults(itemResults, payload, items, input2, optoutStart));
+          return Promise.all(proms).then(() => handleTupleResults(itemResults, payload, items2, input2, optoutStart));
         }
-        return handleTupleResults(itemResults, payload, items, input2, optoutStart);
+        return handleTupleResults(itemResults, payload, items2, input2, optoutStart);
       };
     });
     $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
@@ -4602,7 +4602,7 @@ function isRef(value) {
 function cloneIssues(issues) {
   return issues.map((iss) => iss.path ? { ...iss, path: iss.path.slice() } : { ...iss });
 }
-function isRecursive(inst, stack, resolve9) {
+function isRecursive(inst, stack, resolve11) {
   const cached5 = recursive.get(inst);
   if (cached5 !== void 0)
     return cached5 ? PROVEN : NONE;
@@ -4612,7 +4612,7 @@ function isRecursive(inst, stack, resolve9) {
   let result = NONE;
   const check3 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve9);
+      const answer = isRecursive(child, stack, resolve11);
       if (answer > result)
         result = answer;
     }
@@ -4623,7 +4623,7 @@ function isRecursive(inst, stack, resolve9) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve9) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve11) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -4687,7 +4687,7 @@ function isRecursive(inst, stack, resolve9) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve9 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve11 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -14180,20 +14180,20 @@ function generateNonOptionalCheck(doc, ctx, schema, accessor) {
 }
 function generateTupleCheck(doc, ctx, schema, accessor) {
   const def = schema._zod.def;
-  const items = def.items;
+  const items2 = def.items;
   const rest2 = def.rest;
   doc.write(`if (!Array.isArray(${accessor})) return INVALID;`);
-  const optinStart = getTupleOptStart2(items, "optin");
-  const optoutStart = getTupleOptStart2(items, "optout");
+  const optinStart = getTupleOptStart2(items2, "optin");
+  const optoutStart = getTupleOptStart2(items2, "optout");
   if (rest2) {
     doc.write(`if (${accessor}.length < ${optinStart}) return INVALID;`);
   } else {
-    doc.write(`if (${accessor}.length < ${optinStart} || ${accessor}.length > ${items.length}) return INVALID;`);
+    doc.write(`if (${accessor}.length < ${optinStart} || ${accessor}.length > ${items2.length}) return INVALID;`);
   }
   const outputVar = newVar(ctx);
   doc.write(`const ${outputVar} = [];`);
-  for (let i = 0; i < items.length; i++) {
-    const itemSchema = items[i];
+  for (let i = 0; i < items2.length; i++) {
+    const itemSchema = items2[i];
     if (i >= optoutStart) {
       doc.write(`if (${outputVar}.length === ${i}) {`);
       doc.indented((d) => {
@@ -14235,7 +14235,7 @@ function generateTupleCheck(doc, ctx, schema, accessor) {
   if (rest2) {
     const iVar = newVar(ctx);
     const elemVar = newVar(ctx);
-    doc.write(`for (let ${iVar} = ${items.length}; ${iVar} < ${accessor}.length; ${iVar}++) {`);
+    doc.write(`for (let ${iVar} = ${items2.length}; ${iVar} < ${accessor}.length; ${iVar}++) {`);
     doc.indented((d) => {
       d.write(`const ${elemVar} = ${accessor}[${iVar}];`);
       const elemOutput = compileChild(d, ctx, rest2, elemVar);
@@ -14245,9 +14245,9 @@ function generateTupleCheck(doc, ctx, schema, accessor) {
   }
   return outputVar;
 }
-function getTupleOptStart2(items, key) {
-  for (let i = items.length - 1; i >= 0; i--) {
-    const omittable = key === "optin" ? items[i]._zod.optin !== void 0 : items[i]._zod.optout === "optional";
+function getTupleOptStart2(items2, key) {
+  for (let i = items2.length - 1; i >= 0; i--) {
+    const omittable = key === "optin" ? items2[i]._zod.optin !== void 0 : items2[i]._zod.optout === "optional";
     if (!omittable)
       return i + 1;
   }
@@ -15438,13 +15438,13 @@ function _intersection(Class2, left, right) {
   });
 }
 // @__NO_SIDE_EFFECTS__
-function _tuple(Class2, items, _paramsOrRest, _params) {
+function _tuple(Class2, items2, _paramsOrRest, _params) {
   const hasRest = _paramsOrRest instanceof $ZodType;
   const params = hasRest ? _params : _paramsOrRest;
   const rest2 = hasRest ? _paramsOrRest : null;
   return new Class2({
     type: "tuple",
-    items,
+    items: items2,
     rest: rest2,
     ...normalizeParams(params)
   });
@@ -18032,13 +18032,13 @@ function intersection(left, right) {
     right
   });
 }
-function tuple(items, _paramsOrRest, _params) {
+function tuple(items2, _paramsOrRest, _params) {
   const hasRest = _paramsOrRest instanceof $ZodType;
   const params = hasRest ? _params : _paramsOrRest;
   const rest2 = hasRest ? _paramsOrRest : null;
   return new ZodTuple({
     type: "tuple",
-    items,
+    items: items2,
     rest: rest2,
     ...util_exports.normalizeParams(params)
   });
@@ -19364,8 +19364,8 @@ function detectVersion(schema, defaultTarget) {
   }
   return defaultTarget ?? "draft-2020-12";
 }
-function applyMinItems(items, minItems) {
-  return items.map((item, index) => index < minItems ? item : item.optional());
+function applyMinItems(items2, minItems) {
+  return items2.map((item, index) => index < minItems ? item : item.optional());
 }
 function decodeJSONPointerSegment(segment) {
   return segment.replace(/~1/g, "/").replace(/~0/g, "~");
@@ -19493,13 +19493,13 @@ function plural(n) {
 }
 function checkArrayGuards(arraySchema, guards) {
   const guard = z.transform((value) => value).check((payload) => {
-    const items = payload.value;
-    if (!Array.isArray(items))
+    const items2 = payload.value;
+    if (!Array.isArray(items2))
       return;
     if (guards.uniqueItems === true) {
       const firstSeen = /* @__PURE__ */ new Map();
-      for (let i = 0; i < items.length; i++) {
-        const key = canonicalKey(items[i], /* @__PURE__ */ new Set());
+      for (let i = 0; i < items2.length; i++) {
+        const key = canonicalKey(items2[i], /* @__PURE__ */ new Set());
         if (key === null)
           continue;
         const first = firstSeen.get(key);
@@ -19510,7 +19510,7 @@ function checkArrayGuards(arraySchema, guards) {
         payload.issues.push({
           code: "custom",
           message: `Array items must be unique: element at index ${i} duplicates the one at index ${first}`,
-          input: items,
+          input: items2,
           path: [i],
           continue: true
         });
@@ -19520,7 +19520,7 @@ function checkArrayGuards(arraySchema, guards) {
       const minContains = guards.minContains ?? 1;
       const ceiling = guards.maxContains !== void 0 ? guards.maxContains + 1 : Number.POSITIVE_INFINITY;
       let matches2 = 0;
-      for (const item of items) {
+      for (const item of items2) {
         if (guards.containsSchema.safeParse(item).success && ++matches2 >= ceiling)
           break;
       }
@@ -19528,7 +19528,7 @@ function checkArrayGuards(arraySchema, guards) {
         payload.issues.push({
           code: "custom",
           message: `Array must contain at least ${minContains} matching ${plural(minContains)}; found ${matches2}`,
-          input: items,
+          input: items2,
           continue: true
         });
       }
@@ -19536,7 +19536,7 @@ function checkArrayGuards(arraySchema, guards) {
         payload.issues.push({
           code: "custom",
           message: `Array must contain at most ${guards.maxContains} matching ${plural(guards.maxContains)}`,
-          input: items,
+          input: items2,
           continue: true
         });
       }
@@ -19821,12 +19821,12 @@ function convertBaseSchema(schema, ctx) {
     }
     case "array": {
       const prefixItems = schema.prefixItems;
-      const items = schema.items;
+      const items2 = schema.items;
       if (prefixItems && Array.isArray(prefixItems)) {
         const minItems = typeof schema.minItems === "number" ? schema.minItems : 0;
         const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
         const positionalItems = applyMinItems(tupleItems, minItems);
-        const rest2 = !Array.isArray(items) ? getTupleRest(items, ctx) : void 0;
+        const rest2 = !Array.isArray(items2) ? getTupleRest(items2, ctx) : void 0;
         const tupleSchema = z.tuple(positionalItems);
         zodSchema = rest2 ? tupleSchema.rest(rest2) : tupleSchema;
         if (typeof schema.minItems === "number") {
@@ -19835,9 +19835,9 @@ function convertBaseSchema(schema, ctx) {
         if (typeof schema.maxItems === "number") {
           zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
         }
-      } else if (Array.isArray(items)) {
+      } else if (Array.isArray(items2)) {
         const minItems = typeof schema.minItems === "number" ? schema.minItems : 0;
-        const tupleItems = items.map((item) => convertSchema(item, ctx));
+        const tupleItems = items2.map((item) => convertSchema(item, ctx));
         const positionalItems = applyMinItems(tupleItems, minItems);
         const rest2 = getTupleRest(schema.additionalItems, ctx);
         const tupleSchema = z.tuple(positionalItems);
@@ -19848,8 +19848,8 @@ function convertBaseSchema(schema, ctx) {
         if (typeof schema.maxItems === "number") {
           zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
         }
-      } else if (items !== void 0) {
-        const element = convertSchema(items, ctx);
+      } else if (items2 !== void 0) {
+        const element = convertSchema(items2, ctx);
         let arraySchema = z.array(element);
         if (typeof schema.minItems === "number") {
           arraySchema = arraySchema.min(schema.minItems);
@@ -20101,21 +20101,21 @@ function visit(schema, fnOrHandlers) {
     const h = fnOrHandlers[node2._zod.def.type];
     return h ? h(node2, rewritten) : node2;
   };
-  const cache3 = /* @__PURE__ */ new Map();
+  const cache5 = /* @__PURE__ */ new Map();
   function run3(s) {
-    const cached5 = cache3.get(s);
+    const cached5 = cache5.get(s);
     if (cached5 === RESOLVING) {
       return new $ZodLazy({
         type: "lazy",
-        getter: () => cache3.get(s)
+        getter: () => cache5.get(s)
       });
     }
     if (cached5 !== void 0)
       return cached5;
-    cache3.set(s, RESOLVING);
+    cache5.set(s, RESOLVING);
     const inner = mapInner(s);
     const mapped = fn(inner, inner !== s);
-    cache3.set(s, mapped);
+    cache5.set(s, mapped);
     return mapped;
   }
   function mapInner(s) {
@@ -21918,11 +21918,520 @@ CREATE INDEX IF NOT EXISTS statusline_snapshots_ts ON statusline_snapshots(ts);
           if (!hasColumn(db, "transcript_files", "head_hash"))
             db.exec("ALTER TABLE transcript_files ADD COLUMN head_hash TEXT");
         }
+      },
+      {
+        // Agent swarms (src/swarm): the coordination ledger. Runs own everything else, so a
+        // deleted run cascades to its tasks, workers, events, blackboard notes and spawns.
+        version: 7,
+        sql: `
+CREATE TABLE IF NOT EXISTS swarm_runs (
+  id TEXT PRIMARY KEY,
+  swarm TEXT NOT NULL,
+  goal TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'active',
+  topology TEXT NOT NULL,
+  session_id TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  ended_at INTEGER,
+  summary TEXT
+);
+CREATE INDEX IF NOT EXISTS swarm_runs_status ON swarm_runs(status, updated_at);
+CREATE INDEX IF NOT EXISTS swarm_runs_swarm ON swarm_runs(swarm, status, created_at);
+CREATE TABLE IF NOT EXISTS swarm_tasks (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  run_id TEXT NOT NULL REFERENCES swarm_runs(id) ON DELETE CASCADE,
+  title TEXT NOT NULL,
+  detail TEXT,
+  role TEXT,
+  status TEXT NOT NULL DEFAULT 'pending',
+  agent_id TEXT,
+  deps TEXT NOT NULL DEFAULT '[]',
+  files TEXT NOT NULL DEFAULT '[]',
+  result TEXT,
+  auto_closed INTEGER NOT NULL DEFAULT 0,
+  created_by TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS swarm_tasks_run ON swarm_tasks(run_id, status);
+CREATE TABLE IF NOT EXISTS swarm_agents (
+  run_id TEXT NOT NULL REFERENCES swarm_runs(id) ON DELETE CASCADE,
+  agent_id TEXT NOT NULL,
+  agent_type TEXT NOT NULL,
+  role TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'running',
+  task_id INTEGER,
+  prompt TEXT,
+  session_id TEXT,
+  spawned_at INTEGER NOT NULL,
+  last_ts INTEGER NOT NULL,
+  ended_at INTEGER,
+  tool_calls INTEGER NOT NULL DEFAULT 0,
+  errors INTEGER NOT NULL DEFAULT 0,
+  last_tool TEXT,
+  summary TEXT,
+  PRIMARY KEY (run_id, agent_id)
+);
+CREATE INDEX IF NOT EXISTS swarm_agents_agent ON swarm_agents(agent_id, spawned_at);
+CREATE TABLE IF NOT EXISTS swarm_events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  run_id TEXT NOT NULL REFERENCES swarm_runs(id) ON DELETE CASCADE,
+  ts INTEGER NOT NULL,
+  agent_id TEXT,
+  role TEXT,
+  kind TEXT NOT NULL,
+  task_id INTEGER,
+  text TEXT,
+  payload TEXT
+);
+CREATE INDEX IF NOT EXISTS swarm_events_run ON swarm_events(run_id, id);
+CREATE TABLE IF NOT EXISTS swarm_notes (
+  run_id TEXT NOT NULL REFERENCES swarm_runs(id) ON DELETE CASCADE,
+  key TEXT NOT NULL,
+  value TEXT NOT NULL,
+  author TEXT,
+  ts INTEGER NOT NULL,
+  version INTEGER NOT NULL DEFAULT 1,
+  PRIMARY KEY (run_id, key)
+);
+-- A spawn reservation exists from PreToolUse(Agent) until the worker starts or the Agent
+-- call returns; it may precede any run (the run opens at SubagentStart).
+CREATE TABLE IF NOT EXISTS swarm_spawns (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  swarm TEXT NOT NULL,
+  run_id TEXT REFERENCES swarm_runs(id) ON DELETE CASCADE,
+  session_id TEXT,
+  agent_type TEXT NOT NULL,
+  prompt TEXT,
+  task_id INTEGER,
+  tool_use_id TEXT,
+  ts INTEGER NOT NULL,
+  consumed INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS swarm_spawns_type ON swarm_spawns(agent_type, consumed, ts);
+CREATE INDEX IF NOT EXISTS swarm_spawns_swarm ON swarm_spawns(swarm, consumed, ts);
+CREATE INDEX IF NOT EXISTS swarm_spawns_run ON swarm_spawns(run_id, consumed, ts);
+CREATE INDEX IF NOT EXISTS swarm_spawns_tool ON swarm_spawns(tool_use_id);
+CREATE INDEX IF NOT EXISTS swarm_agents_session ON swarm_agents(session_id, status);
+`
       }
     ];
   }
 });
 
+// src/storage/sqlite/swarm.ts
+function jsonArray(raw) {
+  if (typeof raw !== "string" || !raw) return [];
+  try {
+    const v = JSON.parse(raw);
+    return Array.isArray(v) ? v : [];
+  } catch {
+    return [];
+  }
+}
+function jsonObject(raw) {
+  if (typeof raw !== "string" || !raw) return null;
+  try {
+    const v = JSON.parse(raw);
+    return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+function toTask(r) {
+  return {
+    ...r,
+    deps: jsonArray(r.deps).filter((n) => Number.isInteger(n)),
+    files: jsonArray(r.files).filter((s) => typeof s === "string"),
+    auto_closed: r.auto_closed === 1
+  };
+}
+function toEvent(r) {
+  return { ...r, payload: jsonObject(r.payload) };
+}
+function toSpawn(r) {
+  return { ...r, consumed: r.consumed === 1 };
+}
+var SqliteSwarmStore;
+var init_swarm = __esm({
+  "src/storage/sqlite/swarm.ts"() {
+    "use strict";
+    init_esm_shims();
+    SqliteSwarmStore = class {
+      constructor(db) {
+        this.db = db;
+      }
+      db;
+      stmts = /* @__PURE__ */ new Map();
+      prep(sql) {
+        let s = this.stmts.get(sql);
+        if (!s) {
+          s = this.db.prepare(sql);
+          this.stmts.set(sql, s);
+        }
+        return s;
+      }
+      immediate(fn) {
+        if (this.db.inTransaction) return fn();
+        return this.db.transaction(fn).immediate();
+      }
+      // --- runs -------------------------------------------------------------------------
+      runCreate(r) {
+        const now = Date.now();
+        this.prep(
+          `INSERT INTO swarm_runs (id, swarm, goal, status, topology, session_id, created_at, updated_at)
+       VALUES (?, ?, ?, 'active', ?, ?, ?, ?)`
+        ).run(r.id, r.swarm, r.goal, r.topology, r.session_id ?? null, now, now);
+        return this.runGet(r.id);
+      }
+      runGet(id) {
+        return this.prep("SELECT * FROM swarm_runs WHERE id = ?").get(id);
+      }
+      runs(opts = {}) {
+        const where = [];
+        const params = [];
+        if (opts.swarm) {
+          where.push("swarm = ?");
+          params.push(opts.swarm);
+        }
+        if (opts.status) {
+          where.push("status = ?");
+          params.push(opts.status);
+        }
+        params.push(Math.max(1, Math.min(opts.limit ?? 50, 500)));
+        return this.prep(
+          `SELECT * FROM swarm_runs ${where.length ? `WHERE ${where.join(" AND ")}` : ""}
+       ORDER BY created_at DESC, rowid DESC LIMIT ?`
+        ).all(...params);
+      }
+      runActive(swarm, sessionId) {
+        return this.prep(
+          `SELECT * FROM swarm_runs WHERE status = 'active' AND (? IS NULL OR swarm = ?)
+       ORDER BY (session_id IS NOT NULL AND session_id = ?) DESC, created_at DESC, rowid DESC
+       LIMIT 1`
+        ).get(swarm ?? null, swarm ?? null, sessionId ?? null);
+      }
+      runUpdate(id, patch) {
+        const sets = ["updated_at = ?"];
+        const params = [Date.now()];
+        if (patch.status !== void 0) {
+          sets.push("status = ?");
+          params.push(patch.status);
+        }
+        if (patch.summary !== void 0) {
+          sets.push("summary = ?");
+          params.push(patch.summary);
+        }
+        if (patch.ended_at !== void 0) {
+          sets.push("ended_at = ?");
+          params.push(patch.ended_at);
+        }
+        params.push(id);
+        this.prep(`UPDATE swarm_runs SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+      }
+      runTouch(id) {
+        this.prep("UPDATE swarm_runs SET updated_at = ? WHERE id = ?").run(Date.now(), id);
+      }
+      // --- tasks ------------------------------------------------------------------------
+      taskAdd(t) {
+        const now = Date.now();
+        const info = this.prep(
+          `INSERT INTO swarm_tasks (run_id, title, detail, role, status, deps, files, created_by, created_at, updated_at)
+       VALUES (?, ?, ?, ?, 'pending', ?, ?, ?, ?, ?)`
+        ).run(
+          t.run_id,
+          t.title,
+          t.detail ?? null,
+          t.role ?? null,
+          JSON.stringify(t.deps ?? []),
+          JSON.stringify(t.files ?? []),
+          t.created_by ?? null,
+          now,
+          now
+        );
+        return this.taskGet(Number(info.lastInsertRowid));
+      }
+      taskGet(id) {
+        const r = this.prep("SELECT * FROM swarm_tasks WHERE id = ?").get(id);
+        return r ? toTask(r) : void 0;
+      }
+      tasks(runId) {
+        return this.prep("SELECT * FROM swarm_tasks WHERE run_id = ? ORDER BY id").all(runId).map(toTask);
+      }
+      taskUpdate(id, patch) {
+        const sets = ["updated_at = ?"];
+        const params = [Date.now()];
+        if (patch.status !== void 0) {
+          sets.push("status = ?");
+          params.push(patch.status);
+        }
+        if (patch.agent_id !== void 0) {
+          sets.push("agent_id = ?");
+          params.push(patch.agent_id);
+        }
+        if (patch.result !== void 0) {
+          sets.push("result = ?");
+          params.push(patch.result);
+        }
+        if (patch.auto_closed !== void 0) {
+          sets.push("auto_closed = ?");
+          params.push(patch.auto_closed ? 1 : 0);
+        }
+        if (patch.files !== void 0) {
+          sets.push("files = ?");
+          params.push(JSON.stringify(patch.files));
+        }
+        params.push(id);
+        this.prep(`UPDATE swarm_tasks SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+      }
+      taskClaim(id, agentId) {
+        const info = this.prep(
+          `UPDATE swarm_tasks SET status = 'active', agent_id = ?, auto_closed = 0, updated_at = ?
+       WHERE id = ? AND status = 'pending'`
+        ).run(agentId, Date.now(), id);
+        return info.changes === 1;
+      }
+      // --- workers ----------------------------------------------------------------------
+      workerUpsert(w) {
+        const now = Date.now();
+        this.prep(
+          `INSERT INTO swarm_agents (run_id, agent_id, agent_type, role, status, task_id, prompt, session_id, spawned_at, last_ts)
+       VALUES (?, ?, ?, ?, 'running', ?, ?, ?, ?, ?)
+       ON CONFLICT(run_id, agent_id) DO UPDATE SET
+         status = 'running', ended_at = NULL, last_ts = excluded.last_ts,
+         task_id = COALESCE(excluded.task_id, swarm_agents.task_id),
+         prompt = COALESCE(excluded.prompt, swarm_agents.prompt)`
+        ).run(
+          w.run_id,
+          w.agent_id,
+          w.agent_type,
+          w.role,
+          w.task_id ?? null,
+          w.prompt ?? null,
+          w.session_id ?? null,
+          now,
+          now
+        );
+        return this.workerGet(w.run_id, w.agent_id);
+      }
+      workerGet(runId, agentId) {
+        return this.prep("SELECT * FROM swarm_agents WHERE run_id = ? AND agent_id = ?").get(
+          runId,
+          agentId
+        );
+      }
+      workerFind(agentId) {
+        return this.prep(
+          "SELECT * FROM swarm_agents WHERE agent_id = ? ORDER BY spawned_at DESC LIMIT 1"
+        ).get(agentId);
+      }
+      workers(runId) {
+        return this.prep("SELECT * FROM swarm_agents WHERE run_id = ? ORDER BY spawned_at").all(
+          runId
+        );
+      }
+      workerUpdate(runId, agentId, patch) {
+        const sets = ["last_ts = ?"];
+        const params = [Date.now()];
+        if (patch.status !== void 0) {
+          sets.push("status = ?");
+          params.push(patch.status);
+        }
+        if (patch.task_id !== void 0) {
+          sets.push("task_id = ?");
+          params.push(patch.task_id);
+        }
+        if (patch.ended_at !== void 0) {
+          sets.push("ended_at = ?");
+          params.push(patch.ended_at);
+        }
+        if (patch.summary !== void 0) {
+          sets.push("summary = ?");
+          params.push(patch.summary);
+        }
+        params.push(runId, agentId);
+        this.prep(`UPDATE swarm_agents SET ${sets.join(", ")} WHERE run_id = ? AND agent_id = ?`).run(
+          ...params
+        );
+      }
+      workerTouch(runId, agentId, tool, error62 = false) {
+        this.prep(
+          `UPDATE swarm_agents SET last_ts = ?, tool_calls = tool_calls + 1, errors = errors + ?,
+         last_tool = COALESCE(?, last_tool)
+       WHERE run_id = ? AND agent_id = ?`
+        ).run(Date.now(), error62 ? 1 : 0, tool, runId, agentId);
+      }
+      // --- events -----------------------------------------------------------------------
+      eventAdd(e) {
+        const info = this.prep(
+          `INSERT INTO swarm_events (run_id, ts, agent_id, role, kind, task_id, text, payload)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+          e.run_id,
+          e.ts ?? Date.now(),
+          e.agent_id ?? null,
+          e.role ?? null,
+          e.kind,
+          e.task_id ?? null,
+          e.text ?? null,
+          e.payload ? JSON.stringify(e.payload) : null
+        );
+        return Number(info.lastInsertRowid);
+      }
+      events(runId, opts = {}) {
+        const limit = Math.max(1, Math.min(opts.limit ?? 100, 1e3));
+        if (opts.after !== void 0) {
+          return this.prep("SELECT * FROM swarm_events WHERE run_id = ? AND id > ? ORDER BY id LIMIT ?").all(
+            runId,
+            opts.after,
+            limit
+          ).map(toEvent);
+        }
+        return this.prep("SELECT * FROM swarm_events WHERE run_id = ? ORDER BY id DESC LIMIT ?").all(
+          runId,
+          limit
+        ).map(toEvent).reverse();
+      }
+      // --- blackboard -------------------------------------------------------------------
+      noteSet(runId, key, value, author) {
+        this.prep(
+          `INSERT INTO swarm_notes (run_id, key, value, author, ts, version) VALUES (?, ?, ?, ?, ?, 1)
+       ON CONFLICT(run_id, key) DO UPDATE SET value = excluded.value, author = excluded.author,
+         ts = excluded.ts, version = swarm_notes.version + 1`
+        ).run(runId, key, value, author, Date.now());
+        return this.noteGet(runId, key);
+      }
+      noteGet(runId, key) {
+        return this.prep("SELECT * FROM swarm_notes WHERE run_id = ? AND key = ?").get(runId, key);
+      }
+      notes(runId) {
+        return this.prep("SELECT * FROM swarm_notes WHERE run_id = ? ORDER BY ts DESC").all(
+          runId
+        );
+      }
+      // --- spawn reservations -----------------------------------------------------------
+      spawnAdd(s) {
+        const info = this.prep(
+          `INSERT INTO swarm_spawns (swarm, run_id, session_id, agent_type, prompt, task_id, tool_use_id, ts)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+          s.swarm,
+          s.run_id ?? null,
+          s.session_id ?? null,
+          s.agent_type,
+          s.prompt ?? null,
+          s.task_id ?? null,
+          s.tool_use_id ?? null,
+          Date.now()
+        );
+        return Number(info.lastInsertRowid);
+      }
+      spawnConsumeByToolUse(toolUseId) {
+        return this.prep("UPDATE swarm_spawns SET consumed = 1 WHERE tool_use_id = ? AND consumed = 0").run(
+          toolUseId
+        ).changes > 0;
+      }
+      spawnTake(agentType, sinceTs, sessionId) {
+        return this.immediate(() => {
+          const r = this.prep(
+            `SELECT * FROM swarm_spawns WHERE agent_type = ? AND consumed = 0 AND ts >= ?
+           AND (? IS NULL OR session_id IS NULL OR session_id = ?)
+         ORDER BY id LIMIT 1`
+          ).get(agentType, sinceTs, sessionId ?? null, sessionId ?? null);
+          if (!r) return void 0;
+          this.prep("UPDATE swarm_spawns SET consumed = 1 WHERE id = ?").run(r.id);
+          return toSpawn({ ...r, consumed: 1 });
+        });
+      }
+      spawnsPending(runId, sinceTs, agentType) {
+        const r = this.prep(
+          `SELECT COUNT(*) n FROM swarm_spawns
+       WHERE run_id = ? AND consumed = 0 AND ts >= ? AND (? IS NULL OR agent_type = ?)`
+        ).get(runId, sinceTs, agentType ?? null, agentType ?? null);
+        return r.n;
+      }
+      spawnsOpen(agentType, sinceTs, sessionId) {
+        return this.prep(
+          `SELECT * FROM swarm_spawns WHERE agent_type = ? AND consumed = 0 AND ts >= ?
+           AND (? IS NULL OR session_id IS NULL OR session_id = ?)
+         ORDER BY id`
+        ).all(agentType, sinceTs, sessionId ?? null, sessionId ?? null).map(toSpawn);
+      }
+      spawnConsume(id) {
+        return this.prep("UPDATE swarm_spawns SET consumed = 1 WHERE id = ? AND consumed = 0").run(id).changes === 1;
+      }
+      spawnsVoid(runId) {
+        return this.prep("UPDATE swarm_spawns SET consumed = 1 WHERE run_id = ? AND consumed = 0").run(
+          runId
+        ).changes;
+      }
+      spawnsPendingOfSwarm(swarm, sinceTs, agentType) {
+        const r = this.prep(
+          `SELECT COUNT(*) n FROM swarm_spawns
+       WHERE swarm = ? AND consumed = 0 AND ts >= ? AND (? IS NULL OR agent_type = ?)`
+        ).get(swarm, sinceTs, agentType ?? null, agentType ?? null);
+        return r.n;
+      }
+      liveWorkersOfSwarm(swarm, sinceTs) {
+        return this.prep(
+          `SELECT a.* FROM swarm_agents a JOIN swarm_runs r ON r.id = a.run_id
+       WHERE r.swarm = ? AND a.status = 'running' AND a.last_ts >= ?`
+        ).all(swarm, sinceTs);
+      }
+      tasksHeldBy(agentId) {
+        return this.prep(
+          "SELECT * FROM swarm_tasks WHERE agent_id = ? AND status = 'active' ORDER BY id"
+        ).all(agentId).map(toTask);
+      }
+      workersOfSession(sessionId) {
+        return this.prep(
+          "SELECT * FROM swarm_agents WHERE session_id = ? AND status = 'running' ORDER BY spawned_at"
+        ).all(sessionId);
+      }
+      eventsPrune(runId, keep) {
+        const cut = this.prep(
+          "SELECT id FROM swarm_events WHERE run_id = ? ORDER BY id DESC LIMIT 1 OFFSET ?"
+        ).get(runId, Math.max(0, keep - 1));
+        if (!cut) return 0;
+        return this.prep("DELETE FROM swarm_events WHERE run_id = ? AND id < ?").run(runId, cut.id).changes;
+      }
+      workerPing(runId, agentId) {
+        this.prep("UPDATE swarm_agents SET last_ts = ? WHERE run_id = ? AND agent_id = ?").run(
+          Date.now(),
+          runId,
+          agentId
+        );
+      }
+      eventLast(runId) {
+        const r = this.prep("SELECT * FROM swarm_events WHERE run_id = ? ORDER BY id DESC LIMIT 1").get(
+          runId
+        );
+        return r ? toEvent(r) : void 0;
+      }
+      eventUpdate(id, patch) {
+        const sets = [];
+        const params = [];
+        if (patch.ts !== void 0) {
+          sets.push("ts = ?");
+          params.push(patch.ts);
+        }
+        if (patch.text !== void 0) {
+          sets.push("text = ?");
+          params.push(patch.text);
+        }
+        if (patch.payload !== void 0) {
+          sets.push("payload = ?");
+          params.push(patch.payload ? JSON.stringify(patch.payload) : null);
+        }
+        if (!sets.length) return;
+        params.push(id);
+        this.prep(`UPDATE swarm_events SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+      }
+    };
+  }
+});
+
 // src/storage/sqlite/adapter.ts
 import Database from "better-sqlite3";
 import * as sqliteVec from "sqlite-vec";
@@ -21985,10 +22494,12 @@ var init_adapter = __esm({
     init_esm_shims();
     init_terms();
     init_schema();
+    init_swarm();
     SqliteAdapter = class _SqliteAdapter {
       constructor(path3, opts = {}) {
         this.path = path3;
         this.db = new Database(path3, { timeout: 2e3 });
+        this.swarm = new SqliteSwarmStore(this.db);
         this.db.pragma("journal_mode = WAL");
         this.db.pragma("synchronous = NORMAL");
         this.db.pragma("foreign_keys = ON");
@@ -22014,6 +22525,7 @@ var init_adapter = __esm({
       path;
       db;
       vectors;
+      swarm;
       stmts = /* @__PURE__ */ new Map();
       /**
        * Prepared-statement cache. better-sqlite3 compiles the SQL on every prepare(), so
@@ -23156,6 +23668,7 @@ var init_adapter = __esm({
             this.db.exec(
               "DELETE FROM events; DELETE FROM snapshots; DELETE FROM sessions; DELETE FROM stats;"
             );
+            this.db.exec("DELETE FROM swarm_runs;");
           }
           if (scope === "graph" || scope === "all") {
             this.db.exec(
@@ -23308,15 +23821,15 @@ function probeServer(root) {
   return `cannot start (${why.trim().slice(-220)})`;
 }
 function pluginCacheStale(stable) {
-  const cache3 = pluginInstallPath("eminiar@eminiar");
-  if (!cache3 || cache3 === stable) return void 0;
-  if (!existsSync8(cache3)) return `${cache3} is missing`;
+  const cache5 = pluginInstallPath("eminiar@eminiar");
+  if (!cache5 || cache5 === stable) return void 0;
+  if (!existsSync8(cache5)) return `${cache5} is missing`;
   for (const rel of CACHE_FINGERPRINT) {
-    if (fileHash(join11(cache3, rel)) !== fileHash(join11(stable, rel))) return `${rel} differs`;
+    if (fileHash(join11(cache5, rel)) !== fileHash(join11(stable, rel))) return `${rel} differs`;
   }
-  if (existsSync8(join11(cache3, ".mcp.json")) && !existsSync8(join11(stable, ".mcp.json")))
+  if (existsSync8(join11(cache5, ".mcp.json")) && !existsSync8(join11(stable, ".mcp.json")))
     return ".mcp.json is present in the cache but not in the stable copy";
-  const probe3 = probeServer(cache3);
+  const probe3 = probeServer(cache5);
   if (probe3) return `cached copy ${probe3}`;
   return void 0;
 }
@@ -23380,7 +23893,9 @@ function registerSettings(stable) {
     const entry = {
       hooks: [{ type: "command", command: hookCmd, timeout: ev2 === "PreCompact" ? 15 : 10 }]
     };
-    if (ev2 === "PreToolUse") entry.matcher = "Bash|Read|Grep|Glob|WebFetch|Agent|Task";
+    if (ev2 === "PreToolUse")
+      entry.matcher = "^(Bash|Read|Grep|Glob|WebFetch|Agent|Task|mcp__.*__em_swarm)$";
+    if (ev2 === "SubagentStart") entry.matcher = "^swarm-";
     if (ev2 === "PostToolUse" || ev2 === "PostToolUseFailure")
       entry.hooks[0].async = true;
     filtered.push(entry);
@@ -23474,6 +23989,7 @@ var init_register = __esm({
       "PreToolUse",
       "PostToolUse",
       "PostToolUseFailure",
+      "SubagentStart",
       "SubagentStop",
       "PreCompact",
       "Stop",
@@ -23789,13 +24305,13 @@ import { spawn } from "child_process";
 import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
 import { join as join15 } from "path";
 function mcpHandshake(bin, ms = 15e3) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve11) => {
     const child = spawn(bin, [], { stdio: ["pipe", "pipe", "pipe"] });
     let buf = "";
     let err = "";
     const timer = setTimeout(() => {
       child.kill();
-      resolve9(`no reply in ${ms / 1e3}s${err ? `: ${err.trim().slice(-200)}` : ""}`);
+      resolve11(`no reply in ${ms / 1e3}s${err ? `: ${err.trim().slice(-200)}` : ""}`);
     }, ms);
     child.stdout.on("data", (d) => {
       buf += d.toString();
@@ -23803,7 +24319,7 @@ function mcpHandshake(bin, ms = 15e3) {
         clearTimeout(timer);
         child.kill();
         const m = /"serverInfo":\{"name":"([^"]+)","version":"([^"]+)"/.exec(buf);
-        resolve9(m ? `${m[1]} v${m[2]}` : "ok");
+        resolve11(m ? `${m[1]} v${m[2]}` : "ok");
       }
     });
     child.stderr.on("data", (d) => {
@@ -23811,7 +24327,7 @@ function mcpHandshake(bin, ms = 15e3) {
     });
     child.on("error", (e) => {
       clearTimeout(timer);
-      resolve9(`spawn failed: ${e.message}`);
+      resolve11(`spawn failed: ${e.message}`);
     });
     child.stdin.write(
       `${JSON.stringify({ jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: "doctor", version: "0" } } })}
@@ -24678,14 +25194,14 @@ var require_array = __commonJS({
     init_esm_shims();
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.splitWhen = exports.flatten = void 0;
-    function flatten(items) {
-      return items.reduce((collection, item) => [].concat(collection, item), []);
+    function flatten(items2) {
+      return items2.reduce((collection, item) => [].concat(collection, item), []);
     }
     exports.flatten = flatten;
-    function splitWhen(items, predicate) {
+    function splitWhen(items2, predicate) {
       const result = [[]];
       let groupIndex = 0;
-      for (const item of items) {
+      for (const item of items2) {
         if (predicate(item)) {
           groupIndex++;
           result[groupIndex] = [];
@@ -25348,7 +25864,7 @@ var require_fill_range = __commonJS({
       }
       return options.stringify === true;
     };
-    var pad = (input2, maxLength, toNumber) => {
+    var pad3 = (input2, maxLength, toNumber) => {
       if (maxLength > 0) {
         let dash = input2[0] === "-" ? "-" : "";
         if (dash) input2 = input2.slice(1);
@@ -25450,7 +25966,7 @@ var require_fill_range = __commonJS({
         if (options.toRegex === true && step > 1) {
           push(a);
         } else {
-          range.push(pad(format(a, index), maxLen, toNumber));
+          range.push(pad3(format(a, index), maxLen, toNumber));
         }
         a = descending ? a - step : a + step;
         index++;
@@ -25521,7 +26037,7 @@ var require_compile = __commonJS({
     init_esm_shims();
     var fill = require_fill_range();
     var utils = require_utils();
-    var compile2 = (ast, options = {}) => {
+    var compile3 = (ast, options = {}) => {
       const walk3 = (node2, parent = {}) => {
         const invalidBlock = utils.isInvalidBrace(parent);
         const invalidNode = node2.invalid === true && options.escapeInvalid === true;
@@ -25563,7 +26079,7 @@ var require_compile = __commonJS({
       };
       return walk3(ast);
     };
-    module.exports = compile2;
+    module.exports = compile3;
   }
 });
 
@@ -25597,7 +26113,7 @@ var require_expand = __commonJS({
       }
       return utils.flatten(result);
     };
-    var expand2 = (ast, options = {}) => {
+    var expand3 = (ast, options = {}) => {
       const rangeLimit = options.rangeLimit === void 0 ? 1e3 : options.rangeLimit;
       const walk3 = (node2, parent = {}) => {
         node2.queue = [];
@@ -25658,7 +26174,7 @@ var require_expand = __commonJS({
       };
       return utils.flatten(walk3(ast));
     };
-    module.exports = expand2;
+    module.exports = expand3;
   }
 });
 
@@ -25771,7 +26287,7 @@ var require_parse = __commonJS({
     init_esm_shims();
     var stringify = require_stringify();
     var {
-      MAX_LENGTH,
+      MAX_LENGTH: MAX_LENGTH2,
       CHAR_BACKSLASH,
       /* \ */
       CHAR_BACKTICK,
@@ -25804,7 +26320,7 @@ var require_parse = __commonJS({
         throw new TypeError("Expected a string");
       }
       const opts = options || {};
-      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH2, opts.maxLength) : MAX_LENGTH2;
       if (input2.length > max) {
         throw new SyntaxError(`Input length (${input2.length}), exceeds max characters (${max})`);
       }
@@ -26009,8 +26525,8 @@ var require_braces = __commonJS({
     "use strict";
     init_esm_shims();
     var stringify = require_stringify();
-    var compile2 = require_compile();
-    var expand2 = require_expand();
+    var compile3 = require_compile();
+    var expand3 = require_expand();
     var parse3 = require_parse();
     var braces = (input2, options = {}) => {
       let output2 = [];
@@ -26042,13 +26558,13 @@ var require_braces = __commonJS({
       if (typeof input2 === "string") {
         input2 = braces.parse(input2, options);
       }
-      return compile2(input2, options);
+      return compile3(input2, options);
     };
     braces.expand = (input2, options = {}) => {
       if (typeof input2 === "string") {
         input2 = braces.parse(input2, options);
       }
-      let result = expand2(input2, options);
+      let result = expand3(input2, options);
       if (options.noempty === true) {
         result = result.filter(Boolean);
       }
@@ -26670,7 +27186,7 @@ var require_parse2 = __commonJS({
     var constants4 = require_constants2();
     var utils = require_utils2();
     var {
-      MAX_LENGTH,
+      MAX_LENGTH: MAX_LENGTH2,
       POSIX_REGEX_SOURCE,
       REGEX_NON_SPECIAL_CHARS,
       REGEX_SPECIAL_CHARS_BACKREF,
@@ -26905,7 +27421,7 @@ var require_parse2 = __commonJS({
       }
       input2 = REPLACEMENTS[input2] || input2;
       const opts = { ...options };
-      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH2, opts.maxLength) : MAX_LENGTH2;
       let len = input2.length;
       if (len > max) {
         throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
@@ -27597,7 +28113,7 @@ var require_parse2 = __commonJS({
     };
     parse3.fastpaths = (input2, options) => {
       const opts = { ...options };
-      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH2, opts.maxLength) : MAX_LENGTH2;
       const len = input2.length;
       if (len > max) {
         throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
@@ -27835,10 +28351,10 @@ var require_micromatch = __commonJS({
       list2 = [].concat(list2);
       let omit2 = /* @__PURE__ */ new Set();
       let keep = /* @__PURE__ */ new Set();
-      let items = /* @__PURE__ */ new Set();
+      let items2 = /* @__PURE__ */ new Set();
       let negatives = 0;
       let onResult = (state) => {
-        items.add(state.output);
+        items2.add(state.output);
         if (options && options.onResult) {
           options.onResult(state);
         }
@@ -27859,7 +28375,7 @@ var require_micromatch = __commonJS({
           }
         }
       }
-      let result = negatives === patterns.length ? [...items] : [...keep];
+      let result = negatives === patterns.length ? [...items2] : [...keep];
       let matches2 = result.filter((item) => !omit2.has(item));
       if (options && matches2.length === 0) {
         if (options.failglob === true) {
@@ -27878,13 +28394,13 @@ var require_micromatch = __commonJS({
     micromatch.not = (list2, patterns, options = {}) => {
       patterns = [].concat(patterns).map(String);
       let result = /* @__PURE__ */ new Set();
-      let items = [];
+      let items2 = [];
       let onResult = (state) => {
         if (options.onResult) options.onResult(state);
-        items.push(state.output);
+        items2.push(state.output);
       };
       let matches2 = new Set(micromatch(list2, patterns, { ...options, onResult }));
-      for (let item of items) {
+      for (let item of items2) {
         if (!matches2.has(item)) {
           result.add(item);
         }
@@ -27918,20 +28434,20 @@ var require_micromatch = __commonJS({
       return res;
     };
     micromatch.some = (list2, patterns, options) => {
-      let items = [].concat(list2);
+      let items2 = [].concat(list2);
       for (let pattern2 of [].concat(patterns)) {
         let isMatch = picomatch(String(pattern2), options);
-        if (items.some((item) => isMatch(item))) {
+        if (items2.some((item) => isMatch(item))) {
           return true;
         }
       }
       return false;
     };
     micromatch.every = (list2, patterns, options) => {
-      let items = [].concat(list2);
+      let items2 = [].concat(list2);
       for (let pattern2 of [].concat(patterns)) {
         let isMatch = picomatch(String(pattern2), options);
-        if (!items.every((item) => isMatch(item))) {
+        if (!items2.every((item) => isMatch(item))) {
           return false;
         }
       }
@@ -28080,8 +28596,8 @@ var require_pattern = __commonJS({
     }
     exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
     function isAffectDepthOfReadingPattern(pattern2) {
-      const basename3 = path3.basename(pattern2);
-      return endsWithSlashGlobStar(pattern2) || isStaticPattern(basename3);
+      const basename4 = path3.basename(pattern2);
+      return endsWithSlashGlobStar(pattern2) || isStaticPattern(basename4);
     }
     exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
     function expandPatternsWithBraceExpansion(patterns) {
@@ -28126,21 +28642,21 @@ var require_pattern = __commonJS({
     exports.removeDuplicateSlashes = removeDuplicateSlashes;
     function partitionAbsoluteAndRelative(patterns) {
       const absolute = [];
-      const relative11 = [];
+      const relative13 = [];
       for (const pattern2 of patterns) {
-        if (isAbsolute(pattern2)) {
+        if (isAbsolute2(pattern2)) {
           absolute.push(pattern2);
         } else {
-          relative11.push(pattern2);
+          relative13.push(pattern2);
         }
       }
-      return [absolute, relative11];
+      return [absolute, relative13];
     }
     exports.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
-    function isAbsolute(pattern2) {
+    function isAbsolute2(pattern2) {
       return path3.isAbsolute(pattern2);
     }
-    exports.isAbsolute = isAbsolute;
+    exports.isAbsolute = isAbsolute2;
   }
 });
 
@@ -28565,11 +29081,11 @@ var require_out = __commonJS({
       async.read(path3, getSettings(optionsOrSettingsOrCallback), callback);
     }
     exports.stat = stat;
-    function statSync13(path3, optionsOrSettings) {
+    function statSync15(path3, optionsOrSettings) {
       const settings = getSettings(optionsOrSettings);
       return sync.read(path3, settings);
     }
-    exports.statSync = statSync13;
+    exports.statSync = statSync15;
     function getSettings(settingsOrOptions = {}) {
       if (settingsOrOptions instanceof settings_1.default) {
         return settingsOrOptions;
@@ -29027,7 +29543,7 @@ var require_queue = __commonJS({
       if (!(_concurrency >= 1)) {
         throw new Error("fastqueue concurrency must be equal to or greater than 1");
       }
-      var cache3 = reusify(Task);
+      var cache5 = reusify(Task);
       var queueHead = null;
       var queueTail = null;
       var _running = 0;
@@ -29106,7 +29622,7 @@ var require_queue = __commonJS({
         return _running === 0 && self.length() === 0;
       }
       function push(value, done) {
-        var current = cache3.get();
+        var current = cache5.get();
         current.context = context;
         current.release = release;
         current.value = value;
@@ -29127,7 +29643,7 @@ var require_queue = __commonJS({
         }
       }
       function unshift(value, done) {
-        var current = cache3.get();
+        var current = cache5.get();
         current.context = context;
         current.release = release;
         current.value = value;
@@ -29149,7 +29665,7 @@ var require_queue = __commonJS({
       }
       function release(holder) {
         if (holder) {
-          cache3.release(holder);
+          cache5.release(holder);
         }
         var next = queueHead;
         if (next && _running <= _concurrency) {
@@ -29199,7 +29715,7 @@ var require_queue = __commonJS({
             errorHandler2(new Error("abort"), val);
           }
           callback.call(context2, new Error("abort"));
-          cache3.release(current);
+          cache5.release(current);
           current = next;
         }
         self.drain = noop;
@@ -29250,41 +29766,41 @@ var require_queue = __commonJS({
       queue.drained = drained;
       return queue;
       function push(value) {
-        var p = new Promise(function(resolve9, reject) {
+        var p = new Promise(function(resolve11, reject) {
           pushCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve9(result);
+            resolve11(result);
           });
         });
         p.catch(noop);
         return p;
       }
       function unshift(value) {
-        var p = new Promise(function(resolve9, reject) {
+        var p = new Promise(function(resolve11, reject) {
           unshiftCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve9(result);
+            resolve11(result);
           });
         });
         p.catch(noop);
         return p;
       }
       function drained() {
-        var p = new Promise(function(resolve9) {
+        var p = new Promise(function(resolve11) {
           process.nextTick(function() {
             if (queue.idle()) {
-              resolve9();
+              resolve11();
             } else {
               var previousDrain = queue.drain;
               queue.drain = function() {
                 if (typeof previousDrain === "function") previousDrain();
-                resolve9();
+                resolve11();
                 queue.drain = previousDrain;
               };
             }
@@ -29781,9 +30297,9 @@ var require_stream3 = __commonJS({
         });
       }
       _getStat(filepath) {
-        return new Promise((resolve9, reject) => {
+        return new Promise((resolve11, reject) => {
           this._stat(filepath, this._fsStatSettings, (error62, stats) => {
-            return error62 === null ? resolve9(stats) : reject(error62);
+            return error62 === null ? resolve11(stats) : reject(error62);
           });
         });
       }
@@ -29808,10 +30324,10 @@ var require_async5 = __commonJS({
         this._readerStream = new stream_1.default(this._settings);
       }
       dynamic(root, options) {
-        return new Promise((resolve9, reject) => {
+        return new Promise((resolve11, reject) => {
           this._walkAsync(root, options, (error62, entries) => {
             if (error62 === null) {
-              resolve9(entries);
+              resolve11(entries);
             } else {
               reject(error62);
             }
@@ -29821,10 +30337,10 @@ var require_async5 = __commonJS({
       async static(patterns, options) {
         const entries = [];
         const stream = this._readerStream.static(patterns, options);
-        return new Promise((resolve9, reject) => {
+        return new Promise((resolve11, reject) => {
           stream.once("error", reject);
           stream.on("data", (entry) => entries.push(entry));
-          stream.once("end", () => resolve9(entries));
+          stream.once("end", () => resolve11(entries));
         });
       }
     };
@@ -31905,8 +32421,8 @@ function neighbors(db, ref, depth = 1, kinds) {
     frontier = next;
     if (!frontier.length || edges.length > 2e3) break;
   }
-  const uniq2 = new Map(edges.map((e) => [`${e.src}|${e.dst}|${e.kind}|${e.source}`, e]));
-  return { root, edges: [...uniq2.values()], nodes: db.graphGetNodes([...seen]) };
+  const uniq3 = new Map(edges.map((e) => [`${e.src}|${e.dst}|${e.kind}|${e.source}`, e]));
+  return { root, edges: [...uniq3.values()], nodes: db.graphGetNodes([...seen]) };
 }
 function path2(db, from, to) {
   const a = resolveNode(db, from);
@@ -34588,9 +35104,9 @@ function loadWorkspaces(root) {
   if (Array.isArray(ws)) globs.push(...ws);
   else if (ws?.packages) globs.push(...ws.packages);
   try {
-    const yaml = join21(root, "pnpm-workspace.yaml");
-    if (existsSync18(yaml)) {
-      for (const m of readFileSync15(yaml, "utf8").matchAll(/^\s*-\s*['"]?([^'"\n#]+?)['"]?\s*$/gm))
+    const yaml3 = join21(root, "pnpm-workspace.yaml");
+    if (existsSync18(yaml3)) {
+      for (const m of readFileSync15(yaml3, "utf8").matchAll(/^\s*-\s*['"]?([^'"\n#]+?)['"]?\s*$/gm))
         globs.push(m[1].trim());
     }
   } catch {
@@ -40663,8 +41179,8 @@ function postmanBody(body) {
 function postmanDescription(d) {
   return isObj(d) ? clip(d.content, 1200) : clip(d, 1200);
 }
-function postmanItems(items, out, depth, count) {
-  for (const raw of items) {
+function postmanItems(items2, out, depth, count) {
+  for (const raw of items2) {
     if (!isObj(raw)) continue;
     if (Array.isArray(raw.item)) {
       out.push(`${"#".repeat(Math.min(2 + depth, 5))} ${String(raw.name ?? "Folder")}`, "");
@@ -42050,14 +42566,14 @@ function buildHistory(ctx, db, opts = {}) {
     };
   });
   const bySha = new Map(commits.map((c) => [c.sha, c]));
-  const resolve9 = (prefix) => {
+  const resolve11 = (prefix) => {
     if (bySha.has(prefix)) return bySha.get(prefix);
     for (const c of commits) if (c.sha.startsWith(prefix)) return c;
     return void 0;
   };
   for (const c of commits) {
     if (c.kind !== "revert" || !c.revertOf) continue;
-    const target = resolve9(c.revertOf);
+    const target = resolve11(c.revertOf);
     if (target) {
       target.revertedBy = c.sha;
       c.origins.push(target.sha);
@@ -46696,7 +47212,7 @@ function toolText(r) {
 }
 async function runAction(ctx, input2) {
   const started = Date.now();
-  const done = (ok, output2) => ({ ok, output: output2, ms: Date.now() - started });
+  const done = (ok2, output2) => ({ ok: ok2, output: output2, ms: Date.now() - started });
   switch (input2.action) {
     case "reindex": {
       const { emReindex: emReindex2 } = await Promise.resolve().then(() => (init_em_graph(), em_graph_exports));
@@ -47055,14 +47571,14 @@ function graphExpand(ctx, opts) {
   const nodeMap = /* @__PURE__ */ new Map([[root.id, root]]);
   for (const m of r.nodes) nodeMap.set(m.node.id, m.node);
   const among = [...db.graphEdgesFrom([...keep], opts.kinds)].filter((e) => keep.has(e.dst));
-  const uniq2 = /* @__PURE__ */ new Map();
-  for (const e of [...r.edges, ...among]) uniq2.set(`${e.src}|${e.dst}|${e.kind}|${e.source}`, e);
+  const uniq3 = /* @__PURE__ */ new Map();
+  for (const e of [...r.edges, ...among]) uniq3.set(`${e.src}|${e.dst}|${e.kind}|${e.source}`, e);
   return {
     root: root.id,
     rootLabel: nodeLabel(root, root.id),
     truncated: r.truncated,
     nodes: [...keep].map((id) => vis(nodeMap.get(id), id, id === root.id)),
-    edges: [...uniq2.values()].map(visEdge)
+    edges: [...uniq3.values()].map(visEdge)
   };
 }
 function graphPathPayload(ctx, from, to) {
@@ -48231,6 +48747,1574 @@ var init_knowledge_api = __esm({
   }
 });
 
+// src/swarm/agents.ts
+import { createHash as createHash5 } from "crypto";
+import {
+  linkSync,
+  lstatSync,
+  mkdirSync as mkdirSync12,
+  readdirSync as readdirSync11,
+  readFileSync as readFileSync24,
+  realpathSync as realpathSync3,
+  renameSync as renameSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync10
+} from "fs";
+import { createRequire as createRequire4 } from "module";
+import { join as join32, relative as relative11 } from "path";
+function yaml() {
+  yamlLib ??= createRequire4(import.meta.url)("yaml");
+  return yamlLib;
+}
+function agentsDir(root) {
+  return join32(root, ".claude", "agents");
+}
+function agentRel(agentType) {
+  return `${AGENTS_REL}/${agentType}.md`;
+}
+function workerTools(tools) {
+  const out = tools.includes("ToolSearch") ? [...tools] : [...tools, "ToolSearch"];
+  for (const prefix of EM_MCP_PREFIXES)
+    for (const t of WORKER_EM_TOOLS) if (!out.includes(prefix + t)) out.push(prefix + t);
+  return out;
+}
+function frontmatter(swarm, role) {
+  const fm = {
+    name: role.agentType,
+    description: `Worker "${role.role}" of the eminiar swarm "${swarm.name}": ${role.description} Spawn it for a task of this swarm and name the task as "task #N" in the prompt; the em-swarm skill coordinates runs.`
+  };
+  if (role.model) fm.model = role.model;
+  if (role.tools) fm.tools = workerTools(role.tools).join(", ");
+  const spawns = role.tools?.some((t) => t === "Agent" || t === "Task");
+  const disallowed = [.../* @__PURE__ */ new Set([...role.disallowedTools ?? [], ...spawns ? [] : ["Agent"]])];
+  if (disallowed.length) fm.disallowedTools = disallowed.join(", ");
+  if (role.skills.length) fm.skills = role.skills;
+  if (role.hooks) {
+    const hooks = Object.fromEntries(
+      Object.entries(role.hooks).filter(([, v]) => Array.isArray(v) && v.length)
+    );
+    if (Object.keys(hooks).length) fm.hooks = hooks;
+  }
+  if (role.isolation) fm.isolation = role.isolation;
+  if (role.maxTurns) fm.maxTurns = role.maxTurns;
+  if (role.effort) fm.effort = role.effort;
+  if (role.color) fm.color = role.color;
+  return fm;
+}
+function renderAgentFile(config2, swarm, role) {
+  const fm = yaml().stringify(frontmatter(swarm, role), { lineWidth: 0 }).trimEnd();
+  if (fm.includes("---"))
+    throw new Error(`agent ${role.agentType}: frontmatter would contain "---"; fix ${config2.rel}`);
+  const stages = swarm.topology === "pipeline" && swarm.stages.length ? ` Stages: ${swarm.stages.join(" \u2192 ")}.` : "";
+  const rest2 = [
+    "",
+    `You are the **${role.role}** worker of the eminiar swarm **${swarm.name}**: ${role.description}`,
+    `Topology ${swarm.topology}: ${TOPOLOGY_RULE[swarm.topology]}${stages}`,
+    "",
+    ...role.prompt ? [role.prompt, ""] : [],
+    "## Swarm protocol",
+    "",
+    '1. eminiar starts you with a swarm brief: the run goal, the open tasks, the shared notes and what the project knows (memories, history, structure). First claim the task your prompt names with `em_swarm {action:"claim", task:N}` (or the next open one with `em_swarm {action:"claim"}`); if the brief says you already hold a task, continue it.',
+    '2. Ask eminiar before acting: `em_recall {query}` for decisions and constraints, `em_history {action:"file", path}` before editing a file, `em_graph_impact {node}` before changing a symbol, `em_symbols` / `em_search` instead of grepping.',
+    '3. Share what other workers need with `em_swarm {action:"post", key, value}` and read theirs with `em_swarm {action:"read"}`.',
+    '4. Close every task with `em_swarm {action:"update", task, status, result}`: status `done`, `failed` or `blocked`; the result says what changed and how you verified it.',
+    "5. Record durable decisions with `em_remember` so later sessions know them.",
+    "6. Your final message goes back to the coordinator: lead with the outcome, then the files you changed and anything left open.",
+    ""
+  ].join("\n");
+  const marker = `${MARKER_PREFIX}swarm=${swarm.name} role=${role.role} hash=${hashOf(fm, rest2)} \xB7 generated from ${config2.rel} by \`eminiar swarm sync\`; edit the YAML, not this file (it is overwritten). -->`;
+  return `---
+${fm}
+---
+${marker}
+${rest2}`;
+}
+function generatedState(raw) {
+  const content = raw.replace(/\r\n/g, "\n");
+  if (!content.startsWith("---\n")) return "foreign";
+  const end = content.indexOf("\n---\n", 3);
+  if (end === -1) return "foreign";
+  const fm = content.slice(4, end);
+  const after = content.slice(end + 5);
+  const nl = after.indexOf("\n");
+  const marker = nl === -1 ? after : after.slice(0, nl);
+  if (!marker.startsWith(MARKER_PREFIX)) return "foreign";
+  const hash2 = HASH_RE.exec(marker)?.[1];
+  if (!hash2) return "foreign";
+  return hashOf(fm, nl === -1 ? "" : after.slice(nl + 1)) === hash2 ? "generated" : "edited";
+}
+function inspect(file3) {
+  let st;
+  try {
+    st = lstatSync(file3);
+  } catch (err) {
+    return err.code === "ENOENT" ? { kind: "missing" } : { kind: "other", why: `cannot inspect it: ${err.message}` };
+  }
+  if (st.isSymbolicLink()) return { kind: "other", why: "it is a symbolic link" };
+  if (!st.isFile()) return { kind: "other", why: "it is not a regular file" };
+  try {
+    const content = readFileSync24(file3, "utf8");
+    return { kind: "file", content, state: generatedState(content) };
+  } catch (err) {
+    return { kind: "other", why: `cannot read it: ${err.message}` };
+  }
+}
+function unsafeDir(root, dir) {
+  let probe3 = dir;
+  for (let i = 0; i < 4; i++) {
+    try {
+      const real = realpathSync3(probe3);
+      const rel = relative11(realpathSync3(root), real);
+      if (rel.startsWith("..") || /^[A-Za-z]:/.test(rel) || rel === "" && probe3 !== root)
+        return `${AGENTS_REL} resolves outside the project (${real}); swarm sync only writes inside the project`;
+      return void 0;
+    } catch {
+      const parent = join32(probe3, "..");
+      if (parent === probe3) break;
+      probe3 = parent;
+    }
+  }
+  return void 0;
+}
+function existingGenerated(dir) {
+  const out = /* @__PURE__ */ new Map();
+  let names;
+  try {
+    names = readdirSync11(dir);
+  } catch {
+    return out;
+  }
+  for (const n of names) {
+    if (!n.startsWith("swarm-") || !n.endsWith(".md")) continue;
+    const e = inspect(join32(dir, n));
+    if (e.kind === "file" && e.state !== "foreign") out.set(n.slice(0, -3), e);
+  }
+  return out;
+}
+function planAgentSync(root, config2, opts = {}) {
+  const dir = agentsDir(root);
+  const wantedRoles = config2?.enabled ? config2.swarms.flatMap((swarm) => swarm.roles.map((role) => ({ swarm, role }))) : [];
+  const unsafe = unsafeDir(root, dir);
+  if (unsafe)
+    return wantedRoles.map(({ role }) => ({
+      agentType: role.agentType,
+      path: agentRel(role.agentType),
+      action: "conflict",
+      reason: unsafe
+    }));
+  const generated = existingGenerated(dir);
+  const actions = [];
+  const wanted = /* @__PURE__ */ new Set();
+  const editedReason = "the generated file was edited by hand; move the edits into the swarm file, then sync with --force";
+  for (const { swarm, role } of wantedRoles) {
+    wanted.add(role.agentType);
+    const path3 = agentRel(role.agentType);
+    let content;
+    try {
+      content = renderAgentFile(config2, swarm, role);
+    } catch (err) {
+      actions.push({
+        agentType: role.agentType,
+        path: path3,
+        action: "conflict",
+        reason: err.message
+      });
+      continue;
+    }
+    const e = inspect(join32(dir, `${role.agentType}.md`));
+    if (e.kind === "missing")
+      actions.push({ agentType: role.agentType, path: path3, action: "create", content });
+    else if (e.kind === "other")
+      actions.push({
+        agentType: role.agentType,
+        path: path3,
+        action: "conflict",
+        reason: `left alone: ${e.why}`
+      });
+    else if (e.state === "foreign")
+      actions.push({
+        agentType: role.agentType,
+        path: path3,
+        action: "conflict",
+        reason: "a hand-written agent file with this name exists; rename the role or the file"
+      });
+    else if (e.state === "edited" && !opts.force)
+      actions.push({ agentType: role.agentType, path: path3, action: "conflict", reason: editedReason });
+    else
+      actions.push({
+        agentType: role.agentType,
+        path: path3,
+        action: e.content === content ? "unchanged" : "update",
+        content
+      });
+  }
+  for (const [name, e] of generated)
+    if (!wanted.has(name))
+      actions.push(
+        e.state === "edited" && !opts.force ? { agentType: name, path: agentRel(name), action: "conflict", reason: editedReason } : {
+          agentType: name,
+          path: agentRel(name),
+          action: "delete",
+          reason: config2?.enabled ? "no longer in the swarm file" : "swarms are disabled"
+        }
+      );
+  return actions;
+}
+function syncAgents(root, config2, opts = {}) {
+  const dir = agentsDir(root);
+  const planned = planAgentSync(root, config2, opts);
+  const actions = [];
+  let changed = 0;
+  for (const { content, ...a } of planned) {
+    const writes = a.action === "create" || a.action === "update" || a.action === "delete";
+    if (opts.dryRun || !writes) {
+      if (writes) changed++;
+      actions.push(a);
+      continue;
+    }
+    const file3 = join32(dir, `${a.agentType}.md`);
+    const tmp = `${file3}.${process.pid}.${Date.now()}.tmp`;
+    try {
+      if (a.action === "delete") unlinkSync2(file3);
+      else {
+        mkdirSync12(dir, { recursive: true });
+        writeFileSync10(tmp, content ?? "");
+        if (a.action === "create") linkSync(tmp, file3);
+        else renameSync2(tmp, file3);
+      }
+      changed++;
+      actions.push(a);
+    } catch (err) {
+      actions.push({
+        ...a,
+        action: "conflict",
+        reason: `could not ${a.action}: ${err.message}`
+      });
+    } finally {
+      try {
+        unlinkSync2(tmp);
+      } catch {
+      }
+    }
+  }
+  return { actions, changed, conflicts: actions.filter((a) => a.action === "conflict").length };
+}
+var MARKER_PREFIX, HASH_RE, WORKER_EM_TOOLS, yamlLib, EM_MCP_PREFIXES, AGENTS_REL, TOPOLOGY_RULE, hashOf;
+var init_agents = __esm({
+  "src/swarm/agents.ts"() {
+    "use strict";
+    init_esm_shims();
+    MARKER_PREFIX = "<!-- eminiar:swarm ";
+    HASH_RE = /\bhash=([0-9a-f]{12})\b/;
+    WORKER_EM_TOOLS = [
+      "em_swarm",
+      "em_recall",
+      "em_memory",
+      "em_remember",
+      "em_search",
+      "em_symbols",
+      "em_history",
+      "em_graph_impact",
+      "em_graph_query",
+      "em_architecture",
+      "em_execute",
+      "em_execute_file",
+      "em_batch_execute",
+      "em_docs",
+      "em_fetch_and_index"
+    ];
+    EM_MCP_PREFIXES = ["mcp__plugin_eminiar_eminiar__", "mcp__eminiar__"];
+    AGENTS_REL = ".claude/agents";
+    TOPOLOGY_RULE = {
+      hierarchical: "the coordinator (the main Claude Code session) plans and assigns the work. Take tasks for your role, report back, and leave planning to the coordinator unless you find work that is missing.",
+      mesh: "peers share one task board. Claim any open task (your role's first), and read the blackboard for what the other workers found.",
+      pipeline: "work moves in stages. You can claim a task only once every task of the earlier stages is done."
+    };
+    hashOf = (fm, rest2) => createHash5("sha1").update(`${fm}
+${rest2}`).digest("hex").slice(0, 12);
+  }
+});
+
+// src/swarm/glob.ts
+function normalize6(g) {
+  let s = g.trim().replace(/\\/g, "/");
+  while (s.startsWith("./")) s = s.slice(2);
+  return s.replace(/\/+/g, "/").replace(/\/$/, "");
+}
+function expand2(g, out = []) {
+  let depth = 0;
+  let start = -1;
+  for (let i = 0; i < g.length; i++) {
+    const c = g[i];
+    if (c === "{") {
+      if (depth === 0) start = i;
+      depth++;
+    } else if (c === "}" && depth > 0) {
+      depth--;
+      if (depth === 0) {
+        const body = g.slice(start + 1, i);
+        const parts = [];
+        let d = 0;
+        let from = 0;
+        for (let j = 0; j < body.length; j++) {
+          if (body[j] === "{") d++;
+          else if (body[j] === "}") d--;
+          else if (body[j] === "," && d === 0) {
+            parts.push(body.slice(from, j));
+            from = j + 1;
+          }
+        }
+        parts.push(body.slice(from));
+        for (const p of parts) {
+          expand2(g.slice(0, start) + p + g.slice(i + 1), out);
+          if (out.length > MAX_EXPANSIONS)
+            throw new GlobError(`expands to more than ${MAX_EXPANSIONS} alternatives`);
+        }
+        return out;
+      }
+    }
+  }
+  if (depth !== 0) throw new GlobError("unbalanced {");
+  out.push(g);
+  return out;
+}
+function tokenize(seg) {
+  const toks = [];
+  for (let i = 0; i < seg.length; i++) {
+    const c = seg[i];
+    if (c === "*") {
+      if (toks.at(-1)?.t !== "any") toks.push({ t: "any" });
+    } else if (c === "?") toks.push({ t: "one" });
+    else if (c === "[") {
+      const end = seg.indexOf("]", i + 2);
+      if (end === -1) throw new GlobError("unclosed [");
+      let body = seg.slice(i + 1, end);
+      const neg = body.startsWith("!") || body.startsWith("^");
+      if (neg) body = body.slice(1);
+      const ranges = [];
+      for (let j = 0; j < body.length; j++) {
+        const a = body[j];
+        if (body[j + 1] === "-" && j + 2 < body.length) {
+          ranges.push([a, body[j + 2]]);
+          j += 2;
+        } else ranges.push([a, a]);
+      }
+      toks.push({ t: "class", neg, ranges });
+      i = end;
+    } else toks.push({ t: "lit", c });
+  }
+  return toks;
+}
+function compile2(glob2) {
+  const hit = cache3.get(glob2);
+  if (hit) return hit;
+  const g = normalize6(glob2);
+  if (g.length > MAX_LENGTH) throw new GlobError(`longer than ${MAX_LENGTH} characters`);
+  const prefix = !/[*?[{]/.test(g);
+  const alts = expand2(g).map(
+    (p) => p.split("/").filter((s, _i, a) => s !== "" || a.length === 1).map((s) => s === "**" ? "**" : tokenize(s))
+  );
+  const c = { alts, prefix };
+  if (cache3.size > 256) cache3.clear();
+  cache3.set(glob2, c);
+  return c;
+}
+function checkGlob(glob2) {
+  compile2(glob2);
+}
+var MAX_EXPANSIONS, MAX_LENGTH, cache3, GlobError;
+var init_glob = __esm({
+  "src/swarm/glob.ts"() {
+    "use strict";
+    init_esm_shims();
+    MAX_EXPANSIONS = 64;
+    MAX_LENGTH = 300;
+    cache3 = /* @__PURE__ */ new Map();
+    GlobError = class extends Error {
+    };
+  }
+});
+
+// src/swarm/types.ts
+var TOPOLOGIES;
+var init_types4 = __esm({
+  "src/swarm/types.ts"() {
+    "use strict";
+    init_esm_shims();
+    TOPOLOGIES = ["hierarchical", "mesh", "pipeline"];
+  }
+});
+
+// src/swarm/config.ts
+import { createHash as createHash6 } from "crypto";
+import { existsSync as existsSync28, readFileSync as readFileSync25 } from "fs";
+import { createRequire as createRequire5 } from "module";
+import { join as join33 } from "path";
+function yaml2() {
+  yamlLib2 ??= createRequire5(import.meta.url)("yaml");
+  return yamlLib2;
+}
+function agentTypeOf(swarm, role) {
+  return `swarm-${swarm}-${role}`;
+}
+function mergeContext(...layers) {
+  const out = { ...DEFAULT_CONTEXT };
+  for (const l of layers) {
+    if (!l) continue;
+    if (l.memories !== void 0) out.memories = l.memories;
+    if (l.docs !== void 0) out.docs = l.docs;
+    if (l.history !== void 0) out.history = l.history;
+    if (l.structure !== void 0) out.structure = l.structure;
+    if (l.insights !== void 0) out.insights = l.insights;
+    if (l.max_chars !== void 0) out.maxChars = l.max_chars;
+  }
+  return out;
+}
+function swarmFile(root) {
+  for (const rel of SWARM_FILES) {
+    const file3 = join33(root, rel);
+    if (existsSync28(file3)) return { file: file3, rel, exists: true };
+  }
+  return { file: join33(root, SWARM_FILES[0]), rel: SWARM_FILES[0], exists: false };
+}
+function enforceIntent(text3) {
+  return topLevelFlag(text3, "enforce", "true") && !topLevelFlag(text3, "enabled", "false");
+}
+function topLevelFlag(text3, key, word) {
+  const w = word === "true" ? "(?:true|True|TRUE)" : "(?:false|False|FALSE)";
+  return new RegExp(
+    `^\\uFEFF?(?:${key}|"${key}"|'${key}')[ \\t]*:[ \\t]+${w}(?:[ \\t]+#.*)?[ \\t]*\\r?$`,
+    "m"
+  ).test(text3);
+}
+function parseSwarmYaml(text3, file3, rel) {
+  const Y = yaml2();
+  const lines = new Y.LineCounter();
+  if (text3.length > MAX_FILE_CHARS)
+    return {
+      state: "invalid",
+      file: file3,
+      rel,
+      enforce: enforceIntent(text3),
+      issues: [{ path: "", message: `the file is larger than ${MAX_FILE_CHARS / 1e3} KB` }]
+    };
+  const doc = Y.parseDocument(text3, {
+    lineCounter: lines,
+    prettyErrors: false,
+    uniqueKeys: true,
+    merge: true
+  });
+  const lineAt = (offset) => offset === void 0 ? void 0 : lines.linePos(offset).line;
+  if (doc.errors.length) {
+    return {
+      state: "invalid",
+      file: file3,
+      rel,
+      enforce: enforceIntent(text3),
+      issues: doc.errors.map((e) => ({
+        path: "",
+        message: e.message.split("\n")[0] ?? e.message,
+        line: lineAt(e.pos?.[0])
+      }))
+    };
+  }
+  const lineOf = (path3) => {
+    const keys = path3.filter((k) => typeof k !== "symbol");
+    for (let n = keys.length; n >= 0; n--) {
+      const node2 = n === 0 ? doc.contents : doc.getIn(keys.slice(0, n), true);
+      if (Y.isNode(node2) && node2.range) return lineAt(node2.range[0]);
+    }
+    return void 0;
+  };
+  let js;
+  try {
+    js = doc.toJS({ maxAliasCount: 200 });
+  } catch (err) {
+    return {
+      state: "invalid",
+      file: file3,
+      rel,
+      enforce: enforceIntent(text3),
+      issues: [{ path: "", message: err.message.split("\n")[0] ?? "unreadable YAML" }]
+    };
+  }
+  if (js === null || js === void 0 || typeof js !== "object" || Array.isArray(js)) {
+    return {
+      state: "invalid",
+      file: file3,
+      rel,
+      enforce: enforceIntent(text3),
+      issues: [{ path: "", message: "expected a mapping with a `swarms:` key", line: 1 }]
+    };
+  }
+  const top2 = js;
+  const enforce = top2.enforce === true && top2.enabled !== false;
+  const issues = [];
+  const issue2 = (path3, message) => issues.push({ path: path3.join("."), message, line: lineOf(path3) });
+  const checkName = (path3, n, what) => {
+    if (!NAME_RE3.test(n) || n.length > NAME_MAX) issue2(path3, `${what} name "${n}": ${NAME_MSG}`);
+  };
+  const rawSwarms = js.swarms;
+  if (rawSwarms && typeof rawSwarms === "object" && !Array.isArray(rawSwarms))
+    for (const [name, s] of Object.entries(rawSwarms)) {
+      checkName(["swarms", name], name, "swarm");
+      const agents = s?.agents;
+      if (agents && typeof agents === "object" && !Array.isArray(agents))
+        for (const role of Object.keys(agents))
+          checkName(["swarms", name, "agents", role], role, "agent");
+    }
+  const parsed = RawFile.safeParse(js);
+  if (!parsed.success) {
+    return {
+      state: "invalid",
+      file: file3,
+      rel,
+      enforce,
+      issues: [
+        ...issues,
+        ...parsed.error.issues.slice(0, 50).map((i) => ({
+          path: i.path.map(String).join("."),
+          message: i.message,
+          line: lineOf(i.path)
+        }))
+      ]
+    };
+  }
+  for (const k of Object.keys(js))
+    if (!TOP_KEYS.has(k) && !k.startsWith("x-") && k !== "<<")
+      issue2(
+        [k],
+        `unknown key "${k}" (top-level keys: ${[...TOP_KEYS].join(", ")}; x-* keys may hold YAML anchors)`
+      );
+  const config2 = resolve9(parsed.data, file3, rel, issue2);
+  if (issues.length) return { state: "invalid", file: file3, rel, enforce, issues };
+  return { state: "ok", config: config2 };
+}
+function resolve9(raw, file3, rel, issue2) {
+  const swarms = [];
+  const seenAgent = /* @__PURE__ */ new Map();
+  const swarmEntries = Object.entries(raw.swarms);
+  if (!swarmEntries.length) issue2(["swarms"], "define at least one swarm");
+  for (const [name, s] of swarmEntries) {
+    const roleEntries = Object.entries(s.agents);
+    if (!roleEntries.length) issue2(["swarms", name, "agents"], "define at least one agent");
+    const roles = roleEntries.map(([role, a]) => {
+      const agentType = agentTypeOf(name, role);
+      if (agentType.length > AGENT_NAME_MAX)
+        issue2(
+          ["swarms", name, "agents", role],
+          `agent name "${agentType}" is longer than ${AGENT_NAME_MAX} characters; shorten the swarm or role name`
+        );
+      const other = seenAgent.get(agentType);
+      if (other)
+        issue2(
+          ["swarms", name, "agents", role],
+          `agent name "${agentType}" is also produced by ${other}; rename one of them`
+        );
+      seenAgent.set(agentType, `swarms.${name}.agents.${role}`);
+      return {
+        swarm: name,
+        role,
+        agentType,
+        description: a.description,
+        prompt: (a.prompt ?? "").trim(),
+        model: a.model ?? raw.defaults?.model,
+        tools: a.tools ? uniq2(a.tools) : void 0,
+        disallowedTools: a.disallowed_tools ? uniq2(a.disallowed_tools) : void 0,
+        skills: uniq2([...raw.defaults?.skills ?? [], ...a.skills ?? []]),
+        hooks: a.hooks,
+        scope: uniq2(a.scope ?? []),
+        memoryTags: uniq2(a.memory_tags ?? []),
+        count: a.count ?? 1,
+        isolation: a.isolation,
+        maxTurns: a.max_turns,
+        effort: a.effort,
+        color: a.color,
+        context: mergeContext(raw.defaults?.context, s.context, a.context)
+      };
+    });
+    const roleNames = new Set(roles.map((r) => r.role));
+    const topology = s.topology ?? "hierarchical";
+    const stages = s.stages ?? [];
+    stages.forEach((st, i) => {
+      if (!roleNames.has(st))
+        issue2(["swarms", name, "stages", String(i)], `stage "${st}" is not an agent of this swarm`);
+    });
+    if (new Set(stages).size !== stages.length)
+      issue2(["swarms", name, "stages"], "a role may appear in stages only once");
+    if (stages.length && topology !== "pipeline")
+      issue2(
+        ["swarms", name, "stages"],
+        `stages only apply to topology: pipeline (this swarm is ${topology}); remove them or change the topology`
+      );
+    swarms.push({
+      name,
+      description: s.description,
+      topology,
+      maxAgents: s.max_agents ?? 4,
+      // A pipeline with no explicit stages runs its roles in the order they are declared.
+      stages: stages.length ? stages : topology === "pipeline" ? roles.map((r) => r.role) : [],
+      instructions: (s.instructions ?? "").trim(),
+      roles
+    });
+  }
+  return {
+    file: file3,
+    rel,
+    enabled: raw.enabled ?? true,
+    sync: raw.sync ?? "auto",
+    enforce: raw.enforce ?? false,
+    allowedAgents: uniq2(raw.allowed_agents ?? []),
+    swarms,
+    hash: createHash6("sha1").update(JSON.stringify(swarms)).digest("hex")
+  };
+}
+function loadSwarmConfig(root) {
+  const { file: file3, rel, exists } = swarmFile(root);
+  if (!exists) return { state: "absent", file: file3, rel };
+  let text3;
+  try {
+    text3 = readFileSync25(file3, "utf8");
+    const hit = cache4.get(file3);
+    if (hit && hit.text === text3) return hit.result;
+  } catch (err) {
+    return {
+      state: "invalid",
+      file: file3,
+      rel,
+      issues: [{ path: "", message: `cannot read ${rel}: ${err.message}` }]
+    };
+  }
+  const result = parseSwarmYaml(text3, file3, rel);
+  if (cache4.size > 32) cache4.clear();
+  cache4.set(file3, { text: text3, result });
+  return result;
+}
+function activeSwarmConfig(root) {
+  const r = loadSwarmConfig(root);
+  return r.state === "ok" && r.config.enabled ? r.config : void 0;
+}
+function findRole(config2, agentType) {
+  if (!agentType) return void 0;
+  for (const swarm of config2.swarms)
+    for (const role of swarm.roles) if (role.agentType === agentType) return { swarm, role };
+  return void 0;
+}
+var yamlLib2, SWARM_FILES, AGENT_NAME_MAX, NAME_RE3, NAME_MAX, NAME_MSG, noFence, FENCE_MSG, MODEL_RE, TOP_KEYS, DEFAULT_CONTEXT, AGENT_COLORS, ToolName, SkillName, Model, Glob, AgentName, RawContext, RawHookCommand, RawHookMatcher, RawHooks, RawAgent, RawSwarm, RawFile, uniq2, MAX_FILE_CHARS, cache4, STARTER_YAML;
+var init_config2 = __esm({
+  "src/swarm/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_zod();
+    init_glob();
+    init_types4();
+    SWARM_FILES = [".eminiar/swarm.yaml", ".eminiar/swarm.yml"];
+    AGENT_NAME_MAX = 64;
+    NAME_RE3 = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+    NAME_MAX = 32;
+    NAME_MSG = "use 1-32 characters: lowercase letters and digits in words joined by single hyphens, starting with a letter (e.g. code-review)";
+    noFence = (s) => !s.includes("---");
+    FENCE_MSG = 'must not contain "---" (Claude Code would end the agent frontmatter there)';
+    MODEL_RE = /^(?:inherit|opusplan|(?:sonnet|opus|haiku|fable)(?:\[1m\])?|(?:[a-z0-9-]+\.)*claude-[a-z0-9.:@-]+(?:\[1m\])?)$/;
+    TOP_KEYS = /* @__PURE__ */ new Set([
+      "version",
+      "enabled",
+      "sync",
+      "enforce",
+      "allowed_agents",
+      "defaults",
+      "swarms"
+    ]);
+    DEFAULT_CONTEXT = {
+      memories: 4,
+      docs: 2,
+      history: true,
+      structure: true,
+      insights: true,
+      maxChars: 4e3
+    };
+    AGENT_COLORS = [
+      "red",
+      "blue",
+      "green",
+      "yellow",
+      "purple",
+      "orange",
+      "pink",
+      "cyan"
+    ];
+    ToolName = external_exports.string().trim().regex(
+      /^[^,\r\n\t]{1,200}$/,
+      "a tool name such as Read, Bash or mcp__server__tool (no commas or tabs)"
+    ).refine(noFence, FENCE_MSG);
+    SkillName = external_exports.string().regex(
+      /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,99}$/,
+      "a skill name such as em-history or eminiar:em-graph"
+    ).refine(noFence, FENCE_MSG);
+    Model = external_exports.string().max(100).regex(MODEL_RE, "a model alias (inherit, sonnet, opus, haiku, fable) or a Claude model id").refine(noFence, FENCE_MSG);
+    Glob = external_exports.string().min(1).max(300).refine(
+      (g) => !g.startsWith("/") && !/^[A-Za-z]:/.test(g) && !g.split(/[\\/]/).includes(".."),
+      "a project-relative glob without '..'"
+    ).superRefine((g, c) => {
+      try {
+        checkGlob(g);
+      } catch (err) {
+        c.addIssue({
+          code: "custom",
+          message: `not a usable glob: ${err instanceof GlobError ? err.message : String(err)}`
+        });
+      }
+    });
+    AgentName = external_exports.string().trim().regex(
+      /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/,
+      "an agent type such as Explore, statusline-setup or my-plugin:reviewer"
+    ).refine(
+      (n) => !n.startsWith("swarm-"),
+      "swarm workers need no entry: they are allowed during a run of their swarm"
+    );
+    RawContext = external_exports.strictObject({
+      memories: external_exports.number().int().min(0).max(10).optional(),
+      docs: external_exports.number().int().min(0).max(10).optional(),
+      history: external_exports.boolean().optional(),
+      structure: external_exports.boolean().optional(),
+      insights: external_exports.boolean().optional(),
+      // SubagentStart context over 10,000 characters is moved to a file Claude may never read.
+      max_chars: external_exports.number().int().min(500).max(9e3).optional()
+    });
+    RawHookCommand = external_exports.strictObject({
+      type: external_exports.literal("command"),
+      command: external_exports.string().trim().min(1).max(2e3).refine(noFence, FENCE_MSG),
+      timeout: external_exports.number().int().positive().max(600).optional()
+    });
+    RawHookMatcher = external_exports.strictObject({
+      matcher: external_exports.string().max(200).refine(noFence, FENCE_MSG).refine((m) => {
+        try {
+          new RegExp(m);
+          return true;
+        } catch {
+          return false;
+        }
+      }, "not a valid regular expression (Claude Code matches tool names with it)").optional(),
+      hooks: external_exports.array(RawHookCommand).min(1).max(10)
+    });
+    RawHooks = external_exports.strictObject({
+      PreToolUse: external_exports.array(RawHookMatcher).max(10).optional(),
+      PostToolUse: external_exports.array(RawHookMatcher).max(10).optional(),
+      Stop: external_exports.array(RawHookMatcher).max(10).optional()
+    });
+    RawAgent = external_exports.strictObject({
+      description: external_exports.string().trim().min(1).max(500).refine(noFence, FENCE_MSG),
+      prompt: external_exports.string().max(2e4).optional(),
+      model: Model.optional(),
+      tools: external_exports.array(ToolName).max(80).optional(),
+      disallowed_tools: external_exports.array(ToolName).max(80).optional(),
+      skills: external_exports.array(SkillName).max(20).optional(),
+      hooks: RawHooks.optional(),
+      scope: external_exports.array(Glob).max(30).optional(),
+      memory_tags: external_exports.array(external_exports.string().trim().min(1).max(64)).max(20).optional(),
+      count: external_exports.number().int().min(1).max(8).optional(),
+      isolation: external_exports.literal("worktree").optional(),
+      max_turns: external_exports.number().int().min(1).max(500).optional(),
+      effort: external_exports.enum(["low", "medium", "high", "xhigh", "max"]).optional(),
+      color: external_exports.enum(AGENT_COLORS).optional(),
+      context: RawContext.optional()
+    });
+    RawSwarm = external_exports.strictObject({
+      description: external_exports.string().trim().min(1).max(500),
+      topology: external_exports.enum(TOPOLOGIES).optional(),
+      max_agents: external_exports.number().int().min(1).max(16).optional(),
+      stages: external_exports.array(external_exports.string()).max(32).optional(),
+      instructions: external_exports.string().max(2e4).optional(),
+      context: RawContext.optional(),
+      // Names are checked in resolve(): zod reports a bad record key only as "Invalid key".
+      agents: external_exports.record(external_exports.string(), RawAgent)
+    });
+    RawFile = external_exports.looseObject({
+      version: external_exports.literal(1).optional(),
+      enabled: external_exports.boolean().optional(),
+      sync: external_exports.enum(["auto", "manual"]).optional(),
+      enforce: external_exports.boolean().optional(),
+      allowed_agents: external_exports.array(AgentName).max(50).optional(),
+      defaults: external_exports.strictObject({
+        model: Model.optional(),
+        skills: external_exports.array(SkillName).max(20).optional(),
+        context: RawContext.optional()
+      }).optional(),
+      swarms: external_exports.record(external_exports.string(), RawSwarm)
+    });
+    uniq2 = (xs) => [...new Set(xs)];
+    MAX_FILE_CHARS = 256e3;
+    cache4 = /* @__PURE__ */ new Map();
+    STARTER_YAML = `# eminiar agent swarms (opt-in). Docs: https://github.com/rydn/eminiar/blob/main/docs/swarms.md
+# Each agent below becomes a Claude Code agent file .claude/agents/swarm-<swarm>-<agent>.md.
+# The main Claude Code session coordinates; start a run with:  /eminiar:em-swarm feature <goal>
+version: 1
+enabled: true
+sync: auto            # regenerate the agent files at session start when this file changes
+# enforce: true        # only swarm workers may run as subagents, and only during a run of their swarm
+# allowed_agents: []   # with enforce: other agent types still allowed, e.g. [statusline-setup]
+
+defaults:
+  model: sonnet
+  context:            # what eminiar tells each worker when it starts
+    memories: 4       # project memories matching the role and task
+    docs: 2           # documentation pages matching the task
+    history: true     # bug-prone files, recent fixes and history lessons in the work area
+    insights: true    # hot files (fan-in \xD7 churn) in the work area
+    structure: true   # the project brief: overview, decisions, constraints
+    max_chars: 4000
+
+swarms:
+  feature:
+    description: Plan, build, test and review a change to the codebase.
+    topology: hierarchical   # hierarchical | mesh | pipeline
+    max_agents: 4            # workers running at once in one run
+    instructions: |
+      Break the goal into tasks one worker can finish in one go, each naming the files it touches.
+      Let the architect design first, fan the coding tasks out, then test, then review.
+    agents:
+      architect:
+        description: Designs the change from the code graph, the history and past decisions.
+        model: opus
+        disallowed_tools: [Edit, Write, NotebookEdit]
+        memory_tags: [decision, constraint]
+        prompt: |
+          Study the affected code with em_architecture, em_symbols and em_graph_impact before proposing anything.
+          Check em_recall for decisions and constraints that apply.
+          Post the design under the blackboard key "design": files to change, the approach, the risks.
+      coder:
+        description: Implements one task at a time with the smallest diff that works.
+        count: 2                 # at most two coders at once
+        prompt: |
+          Read the "design" note first: em_swarm {action:"read", key:"design"}.
+          Before editing a file run em_history {action:"file", path} and respect its fix record.
+          Keep the change minimal and consistent with the surrounding code, and run the relevant tests.
+      tester:
+        description: Writes and runs tests that pin the new behaviour and its edge cases.
+        prompt: |
+          Cover the behaviour the task describes, including edge cases and failure paths.
+          Run the tests and report exact failures. Never weaken a test to make it pass.
+      reviewer:
+        description: Adversarial reviewer that tries to break the change before it ships.
+        model: opus
+        disallowed_tools: [Edit, Write, NotebookEdit]
+        memory_tags: [constraint, preference]
+        prompt: |
+          Review the diff for correctness bugs, missed edge cases, broken conventions and missing tests.
+          Every finding needs a concrete failing input or scenario.
+          Do not fix anything yourself: add each finding as a task for the coder role with
+          em_swarm {action:"plan", tasks:[{title, detail, role:"coder"}]}.
+
+  review:
+    description: Review the working tree from several angles at once.
+    topology: mesh
+    max_agents: 3
+    agents:
+      correctness:
+        description: Hunts for logic errors and unhandled edge cases.
+        disallowed_tools: [Edit, Write, NotebookEdit]
+        prompt: Find bugs, each with a concrete failing input. Post each under the key "finding-<n>".
+      security:
+        description: Looks for injection, path traversal, leaked secrets and unsafe defaults.
+        disallowed_tools: [Edit, Write, NotebookEdit]
+        prompt: Report only exploitable issues, each with the input that triggers it.
+      tests:
+        description: Checks that every changed behaviour has a test that would fail without it.
+        disallowed_tools: [Edit, Write, NotebookEdit]
+        prompt: List untested behaviour together with the test you would add.
+`;
+  }
+});
+
+// src/swarm/runtime.ts
+import { randomBytes } from "crypto";
+import { existsSync as existsSync29, statSync as statSync12 } from "fs";
+import { isAbsolute, join as join34, relative as relative12 } from "path";
+function clip3(s, n) {
+  const t = s.trim();
+  if (t.length <= n) return t;
+  let cut = t.slice(0, Math.max(0, n - 1));
+  const last = cut.charCodeAt(cut.length - 1);
+  if (last >= 55296 && last <= 56319) cut = cut.slice(0, -1);
+  return `${cut}\u2026`;
+}
+function localDate(ts) {
+  const d = new Date(ts);
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+function callerOf(config2, ids) {
+  if (!ids.agentId && !ids.agentType) return { label: COORDINATOR };
+  const hit = findRole(config2, ids.agentType);
+  if (hit)
+    return {
+      label: hit.role.role,
+      agentId: ids.agentId,
+      agentType: ids.agentType,
+      swarm: hit.swarm,
+      role: hit.role
+    };
+  return { label: ids.agentType || "subagent", agentId: ids.agentId, agentType: ids.agentType };
+}
+function requireActive(db, run3) {
+  const status = db.swarm.runGet(run3.id)?.status ?? "deleted";
+  if (status !== "active")
+    throw new SwarmError(
+      `run ${run3.id} is ${status}; start a new run with em_swarm {action:"start", swarm, goal}`
+    );
+}
+function staleHeld(db, run3, all, now = Date.now()) {
+  const workers = new Map(db.swarm.workers(run3.id).map((w) => [w.agent_id, w]));
+  return all.filter((t) => {
+    if (t.status !== "active" || !t.agent_id || t.agent_id === COORDINATOR) return false;
+    const w = workers.get(t.agent_id) ?? db.swarm.workerFind(t.agent_id);
+    if (!w) return false;
+    return w.status === "done" || now - w.last_ts >= STALE_MS;
+  });
+}
+function finishRun(ctx, db, run3, caller, opts) {
+  if (!isCoordinator(caller))
+    throw new SwarmError("only the coordinator (the main session) can finish a run");
+  if (!FINISH.includes(opts.status))
+    throw new SwarmError(`status must be one of ${FINISH.join(", ")}`);
+  const summary = opts.summary?.trim() ? clip3(opts.summary, RESULT_MAX) : null;
+  const now = Date.now();
+  db.swarm.immediate(() => {
+    requireActive(db, run3);
+    const active = db.swarm.tasks(run3.id).filter((t) => t.status === "active").length;
+    const running2 = db.swarm.workers(run3.id).filter((w) => w.status === "running");
+    for (const w of running2)
+      db.swarm.workerUpdate(run3.id, w.agent_id, {
+        status: "done",
+        ended_at: now,
+        summary: w.summary ?? "closed when the run finished"
+      });
+    db.swarm.runUpdate(run3.id, { status: opts.status, summary, ended_at: now });
+    const left = [
+      active ? `${active} task(s) still active` : "",
+      running2.length ? `${running2.length} worker(s) still running were closed` : ""
+    ].filter(Boolean);
+    db.swarm.eventAdd({
+      run_id: run3.id,
+      kind: "run_finish",
+      role: COORDINATOR,
+      text: `${opts.status}${summary ? `: ${firstLine2(summary).slice(0, 160)}` : ""}${left.length ? ` (${left.join(", ")})` : ""}`
+    });
+  });
+  const closed = db.swarm.runGet(run3.id);
+  if (!opts.remember) return { run: closed };
+  try {
+    return { run: closed, memory: rememberRun(ctx, db, closed) };
+  } catch (err) {
+    return { run: closed, memoryError: err.message };
+  }
+}
+function rememberRun(ctx, db, run3) {
+  const tasks = db.swarm.tasks(run3.id);
+  const workers = db.swarm.workers(run3.id);
+  const date5 = localDate(run3.created_at);
+  const minutes = Math.max(1, Math.round(((run3.ended_at ?? Date.now()) - run3.created_at) / 6e4));
+  const lines = [
+    `Swarm run ${run3.id} (swarm "${run3.swarm}", ${run3.topology}, ${date5}): ${run3.status}.`,
+    `Goal: ${run3.goal}`,
+    ...run3.summary ? [`Outcome: ${run3.summary}`] : [],
+    `${tasks.length} task(s), ${workers.length} worker(s), ${minutes} min.`,
+    ...tasks.map(
+      (t) => `- #${t.id} [${t.status}${t.auto_closed ? ", auto-closed" : ""}]${t.role ? ` (${t.role})` : ""} ${t.title}${t.result ? ` \u2014 ${clip3(firstLine2(t.result), 200)}` : ""}`
+    )
+  ];
+  const slug = slugify2(run3.goal.replace(/^\(ad hoc\)\s*/, ""), 32) || run3.swarm;
+  const base = `swarm/run-${date5}-${slug}`;
+  const taken = (n) => !!db.memoryGetByName(n) || existsSync29(join34(ctx.root, relOf(ctx, n)));
+  const suffix = run3.id.slice(-6);
+  let name = base;
+  for (let i = 0; taken(name) && i < 50; i++)
+    name = i === 0 ? `${base}-${suffix}` : `${base}-${suffix}-${i}`;
+  const r = write(ctx, db, {
+    name,
+    kind: "note",
+    content: lines.join("\n"),
+    tags: ["swarm", run3.swarm],
+    related: [...new Set(tasks.flatMap((t) => t.files))].filter((f) => {
+      try {
+        return statSync12(join34(ctx.root, f)).isFile();
+      } catch {
+        return false;
+      }
+    }).slice(0, 20)
+  });
+  return r.name;
+}
+function toolIo(tool) {
+  const t = tool.replace(/^mcp__.*__/, "");
+  if (t === "em_swarm") return "swarm";
+  if (/^(Edit|Write|MultiEdit|NotebookEdit|em_remember)$/.test(t)) return "write";
+  if (/^(Bash|em_execute|em_execute_file|em_batch_execute)$/.test(t)) return "exec";
+  if (/^(Read|Grep|Glob|LS|WebFetch|WebSearch|em_search|em_recall|em_symbols|em_history|em_graph_\w+|em_architecture|em_docs|em_memory|em_fetch_and_index|em_index_status)$/.test(
+    t
+  ))
+    return "read";
+  return "other";
+}
+function stopWorkers(db, workers, why, now) {
+  for (const w of workers) {
+    for (const t of db.swarm.tasksHeldBy(w.agent_id)) {
+      db.swarm.taskUpdate(t.id, { status: "pending", agent_id: null, auto_closed: false });
+      db.swarm.eventAdd({
+        run_id: t.run_id,
+        kind: "auto_close",
+        role: w.role,
+        agent_id: w.agent_id,
+        task_id: t.id,
+        text: `released back to pending: ${why}`
+      });
+    }
+    db.swarm.workerUpdate(w.run_id, w.agent_id, { status: "done", ended_at: now, task_id: null });
+    db.swarm.eventAdd({
+      run_id: w.run_id,
+      kind: "stop",
+      role: w.role,
+      agent_id: w.agent_id,
+      text: why
+    });
+    db.swarm.runTouch(w.run_id);
+  }
+  return workers;
+}
+function releaseWorkers(db, run3, caller, opts) {
+  if (!isCoordinator(caller))
+    throw new SwarmError("only the coordinator (the main session) can release workers");
+  const now = Date.now();
+  return db.swarm.immediate(() => {
+    const running2 = db.swarm.workers(run3.id).filter((w) => w.status === "running");
+    const agent = opts.agent?.trim().replace(/^agent-/, "");
+    const pick2 = agent ? running2.filter((w) => w.agent_id.replace(/^agent-/, "").startsWith(agent)) : opts.role ? running2.filter((w) => w.role === opts.role) : running2.filter((w) => now - w.last_ts >= STALE_MS);
+    if (agent && pick2.length > 1)
+      throw new SwarmError(
+        `"${opts.agent}" matches ${pick2.length} workers (${pick2.map((w) => w.agent_id).join(", ")}); give more of the id`
+      );
+    return stopWorkers(db, pick2, "released by the coordinator", now);
+  });
+}
+function workerStatus(w, now = Date.now()) {
+  if (w.status === "done") return "done";
+  return now - w.last_ts >= STALE_MS ? "stale" : "running";
+}
+function runSnapshot(db, run3, events = 40) {
+  const now = Date.now();
+  const tasks = db.swarm.tasks(run3.id);
+  const workers = db.swarm.workers(run3.id).map((w) => ({ ...w, status: workerStatus(w, now) }));
+  const taskCounts = {
+    pending: 0,
+    active: 0,
+    done: 0,
+    failed: 0,
+    blocked: 0
+  };
+  for (const t of tasks) taskCounts[t.status] = (taskCounts[t.status] ?? 0) + 1;
+  const workerCounts = { running: 0, done: 0, stale: 0 };
+  for (const w of workers) workerCounts[w.status]++;
+  const mine = new Set(workers.map((w) => w.agent_id));
+  const holders = [];
+  for (const t of tasks) {
+    if (t.status !== "active" || !t.agent_id || mine.has(t.agent_id) || t.agent_id === COORDINATOR)
+      continue;
+    const w = db.swarm.workerFind(t.agent_id);
+    if (w && !holders.some((h) => h.agent_id === w.agent_id))
+      holders.push({ ...w, status: workerStatus(w, now) });
+  }
+  return {
+    run: run3,
+    tasks,
+    workers,
+    holders,
+    notes: db.swarm.notes(run3.id),
+    events: events > 0 ? db.swarm.events(run3.id, { limit: events }) : [],
+    counts: {
+      tasks: taskCounts,
+      workers: workerCounts,
+      toolCalls: workers.reduce((n, w) => n + w.tool_calls, 0),
+      errors: workers.reduce((n, w) => n + w.errors, 0),
+      autoClosed: tasks.filter((t) => t.auto_closed).length,
+      staleHeld: staleHeld(db, run3, tasks, now).length
+    }
+  };
+}
+var STALE_MS, SPAWN_TTL_MS, SPAWN_MATCH_MS, DENY_COLLAPSE_MS, RESULT_MAX, SwarmError, firstLine2, pad, COORDINATOR, isCoordinator, FINISH;
+var init_runtime = __esm({
+  "src/swarm/runtime.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_store();
+    init_config2();
+    STALE_MS = 15 * 6e4;
+    SPAWN_TTL_MS = 2 * 6e4;
+    SPAWN_MATCH_MS = 10 * 6e4;
+    DENY_COLLAPSE_MS = 5 * 6e4;
+    RESULT_MAX = 4e3;
+    SwarmError = class extends Error {
+    };
+    firstLine2 = (s) => s.trim().split("\n")[0] ?? "";
+    pad = (n) => String(n).padStart(2, "0");
+    COORDINATOR = "coordinator";
+    isCoordinator = (c) => c.label === COORDINATOR && !c.agentId && !c.agentType;
+    FINISH = ["done", "failed", "cancelled"];
+  }
+});
+
+// src/ui/swarm-api.ts
+import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname12 } from "path";
+function runCounts(db, run3, now) {
+  const tasks = {
+    pending: 0,
+    active: 0,
+    done: 0,
+    failed: 0,
+    blocked: 0,
+    total: 0
+  };
+  for (const t of db.swarm.tasks(run3.id)) {
+    tasks[t.status]++;
+    tasks.total++;
+  }
+  const workers = { running: 0, done: 0, stale: 0 };
+  for (const w of db.swarm.workers(run3.id)) {
+    const s = workerStatus(w, now);
+    workers[s]++;
+  }
+  return { tasks, workers };
+}
+function swarmView(spec, files) {
+  return {
+    name: spec.name,
+    description: spec.description,
+    topology: spec.topology,
+    maxAgents: spec.maxAgents,
+    stages: spec.stages,
+    instructions: spec.instructions,
+    roles: spec.roles.map((r) => ({
+      role: r.role,
+      agentType: r.agentType,
+      description: r.description,
+      // null: the role inherits the session's model / keeps every tool.
+      model: r.model ?? null,
+      count: r.count,
+      tools: r.tools ?? null,
+      disallowedTools: r.disallowedTools ?? null,
+      skills: r.skills,
+      scope: r.scope,
+      memoryTags: r.memoryTags,
+      isolation: r.isolation ?? null,
+      hasHooks: !!r.hooks && Object.values(r.hooks).some((v) => Array.isArray(v) && v.length > 0),
+      file: files.get(r.agentType) ?? {
+        path: `.claude/agents/${r.agentType}.md`,
+        action: "disabled"
+      }
+    }))
+  };
+}
+function listRuns(db, limit) {
+  const active = db.swarm.runs({ status: "active", limit: RUNS_LIMIT_MAX });
+  const room = Math.max(0, limit - active.length);
+  const rest2 = db.swarm.runs({ limit: Math.min(RUNS_LIMIT_MAX, room + active.length + 1) }).filter((r) => r.status !== "active");
+  return { runs: [...active, ...rest2.slice(0, room)], more: rest2.length > room };
+}
+function swarmOverview(ctx, limit = RUNS_LIMIT) {
+  const loaded = loadSwarmConfig(ctx.root);
+  const now = Date.now();
+  const db = getStorage(ctx);
+  const runsLimit = Math.max(1, Math.min(Math.floor(limit) || RUNS_LIMIT, RUNS_LIMIT_MAX));
+  const listed = listRuns(db, runsLimit);
+  const runs = listed.runs.map((r) => ({
+    id: r.id,
+    swarm: r.swarm,
+    goal: r.goal,
+    status: r.status,
+    topology: r.topology,
+    created_at: r.created_at,
+    updated_at: r.updated_at,
+    ended_at: r.ended_at,
+    counts: runCounts(db, r, now)
+  }));
+  const runsMore = listed.more;
+  if (loaded.state === "absent")
+    return {
+      state: "absent",
+      enabled: false,
+      file: loaded.rel,
+      issues: [],
+      swarms: [],
+      orphans: [],
+      syncNeeded: false,
+      runs,
+      runsMore,
+      runsLimit,
+      starter: STARTER_YAML,
+      now
+    };
+  if (loaded.state === "invalid")
+    return {
+      state: "invalid",
+      enabled: false,
+      file: loaded.rel,
+      issues: loaded.issues,
+      swarms: [],
+      orphans: [],
+      syncNeeded: false,
+      runs,
+      runsMore,
+      runsLimit,
+      now
+    };
+  const config2 = loaded.config;
+  const plan = planAgentSync(ctx.root, config2);
+  const roleTypes = new Set(config2.swarms.flatMap((s) => s.roles.map((r) => r.agentType)));
+  const files = new Map(
+    plan.filter((a) => roleTypes.has(a.agentType)).map((a) => [
+      a.agentType,
+      { path: a.path, action: a.action, reason: a.reason }
+    ])
+  );
+  return {
+    state: "ok",
+    enabled: config2.enabled,
+    sync: config2.sync,
+    file: config2.rel,
+    issues: [],
+    swarms: config2.swarms.map((s) => swarmView(s, files)),
+    // Generated files the YAML no longer produces (or every one, when disabled).
+    orphans: plan.filter((a) => !roleTypes.has(a.agentType)).map((a) => ({ path: a.path, agentType: a.agentType, reason: a.reason ?? null })),
+    syncNeeded: plan.some(
+      (a) => a.action === "create" || a.action === "update" || a.action === "delete"
+    ),
+    runs,
+    runsMore,
+    runsLimit,
+    now
+  };
+}
+function busySegments(events, opts = {}) {
+  const gap = opts.gap ?? SEGMENT_GAP_MS;
+  const out = [];
+  let cur;
+  for (const e of [...events].sort((a, b) => a.ts - b.ts || a.id - b.id)) {
+    if (!cur || e.ts - cur.end > gap) {
+      cur = {
+        start: e.ts,
+        end: e.ts,
+        n: 0,
+        errors: 0,
+        io: { read: 0, write: 0, exec: 0, swarm: 0, other: 0 }
+      };
+      out.push(cur);
+    }
+    cur.end = Math.max(cur.end, e.ts);
+    cur.n++;
+    if (e.kind === "tool_error") cur.errors++;
+    if (e.kind !== "start" && e.kind !== "stop") cur.io[ioOf(e)]++;
+  }
+  const last = out[out.length - 1];
+  if (last && opts.running && opts.now !== void 0 && opts.now - last.end <= gap) {
+    last.end = opts.now;
+    last.open = true;
+  }
+  return out;
+}
+function newestEvents(db, runId, max = TIMELINE_EVENTS_MAX) {
+  const latest = db.swarm.events(runId, { limit: READ_PAGE });
+  if (latest.length < READ_PAGE)
+    return latest.length > max ? { events: latest.slice(-max), cut: true } : { events: latest, cut: false };
+  const first = db.swarm.events(runId, { after: 0, limit: 1 })[0];
+  const chunks = [latest];
+  let have = latest.length;
+  let upper = latest[0].id;
+  let idsPerEvent = Math.max(1, (latest[latest.length - 1].id - upper + 1) / latest.length);
+  while (have < max && upper > first.id) {
+    const want = Math.min(max - have, 5 * READ_PAGE);
+    let lower = Math.max(first.id - 1, Math.floor(upper - want * idsPerEvent) - 1);
+    let win = [];
+    let after = lower;
+    for (; ; ) {
+      const page = db.swarm.events(runId, { after, limit: READ_PAGE });
+      let end = page.length < READ_PAGE;
+      for (const e of page) {
+        if (e.id >= upper) {
+          end = true;
+          break;
+        }
+        win.push(e);
+      }
+      if (end) break;
+      after = page[page.length - 1].id;
+      if (win.length > 2 * want + READ_PAGE) {
+        const dense = Math.max(1, (after - lower) / win.length);
+        lower = Math.max(after, Math.floor(upper - want * dense) - 1);
+        win = [];
+        after = lower;
+      }
+    }
+    chunks.unshift(win);
+    have += win.length;
+    idsPerEvent = win.length ? Math.max(1, (upper - lower) / win.length) : idsPerEvent * 2;
+    upper = lower + 1;
+  }
+  const all = chunks.flat();
+  return {
+    events: all.length > max ? all.slice(-max) : all,
+    cut: all.length > max || upper > first.id
+  };
+}
+function clipTask(t) {
+  if ((t.detail?.length ?? 0) <= TASK_TEXT_MAX && (t.result?.length ?? 0) <= TASK_TEXT_MAX)
+    return t;
+  return { ...t, detail: clipText(t.detail), result: clipText(t.result), clipped: true };
+}
+function runDetail(ctx, run3, opts = {}) {
+  const db = getStorage(ctx);
+  const snap = runSnapshot(db, run3, opts.events === false ? 0 : SNAPSHOT_EVENTS);
+  const now = Date.now();
+  const { events: all, cut } = newestEvents(db, run3.id);
+  const byAgent2 = /* @__PURE__ */ new Map();
+  for (const e of all) {
+    if (!e.agent_id) continue;
+    const list2 = byAgent2.get(e.agent_id) ?? [];
+    list2.push(e);
+    byAgent2.set(e.agent_id, list2);
+  }
+  const loaded = loadSwarmConfig(ctx.root);
+  const spec = loaded.state === "ok" ? loaded.config.swarms.find((s) => s.name === run3.swarm) : void 0;
+  const roles = [
+    .../* @__PURE__ */ new Set([
+      ...spec?.roles.map((r) => r.role) ?? [],
+      ...snap.workers.map((w) => w.role),
+      ...snap.tasks.map((t) => t.role).filter((r) => !!r)
+    ])
+  ];
+  const since = opts.tasksSince;
+  const tasks = (since === void 0 ? snap.tasks : snap.tasks.filter((t) => t.updated_at >= since - TASKS_SINCE_OVERLAP_MS)).map(clipTask);
+  return {
+    ...snap,
+    tasks,
+    /** Every task of the run, whether or not `tasks` holds them all. */
+    taskCount: snap.tasks.length,
+    /** `tasks` holds only the tasks updated since `tasksSince`. */
+    tasksPartial: since !== void 0,
+    roles,
+    stages: spec?.stages ?? [],
+    maxAgents: spec?.maxAgents ?? null,
+    configured: !!spec,
+    timeline: {
+      start: run3.created_at,
+      end: run3.ended_at ?? (run3.status === "active" ? now : run3.updated_at),
+      cut,
+      /** With `cut`: the time of the oldest event drawn; activity before it is not shown. */
+      from: cut ? all[0]?.ts ?? null : null,
+      workers: snap.workers.map((w) => ({
+        agent_id: w.agent_id,
+        role: w.role,
+        status: w.status,
+        spawned_at: w.spawned_at,
+        ended_at: w.ended_at,
+        segments: busySegments(byAgent2.get(w.agent_id) ?? [], {
+          now,
+          running: w.status === "running" && run3.status === "active"
+        })
+      }))
+    },
+    /** The run's newest event id (the snapshot's own events may stop short of it). */
+    lastEventId: db.swarm.eventLast(run3.id)?.id ?? 0,
+    staleMs: STALE_MS,
+    now
+  };
+}
+function runFromId(ctx, id) {
+  if (typeof id !== "string" || !id) return { error: fail(400, "id required") };
+  if (!RUN_ID_RE.test(id)) return { error: fail(400, `invalid run id "${id.slice(0, 40)}"`) };
+  const run3 = getStorage(ctx).swarm.runGet(id);
+  if (!run3) return { error: fail(404, `run ${id} not found`) };
+  return { run: run3 };
+}
+function initSwarm(ctx) {
+  const where = swarmFile(ctx.root);
+  if (where.exists) return fail(409, `${where.rel} already exists; edit it instead`);
+  mkdirSync13(dirname12(where.file), { recursive: true });
+  try {
+    writeFileSync11(where.file, STARTER_YAML, { flag: "wx" });
+  } catch (err) {
+    if (err.code === "EEXIST")
+      return fail(409, `${where.rel} already exists; edit it instead`);
+    throw err;
+  }
+  const config2 = activeSwarmConfig(ctx.root);
+  return ok({ created: where.rel, sync: syncAgents(ctx.root, config2) });
+}
+function syncSwarm(ctx) {
+  const loaded = loadSwarmConfig(ctx.root);
+  if (loaded.state === "absent")
+    return fail(409, `no ${loaded.rel}; create it first (eminiar swarm init)`);
+  if (loaded.state === "invalid")
+    return fail(400, `${loaded.rel} is invalid; fix it before syncing`, { issues: loaded.issues });
+  return ok(syncAgents(ctx.root, loaded.config));
+}
+function finishSwarmRun(ctx, body) {
+  const { run: run3, error: error62 } = runFromId(ctx, body.id);
+  if (error62 || !run3) return error62 ?? fail(400, "id required");
+  const status = body.status;
+  if (typeof status !== "string" || !FINISH_STATUSES.includes(status))
+    return fail(400, `status must be one of ${FINISH_STATUSES.join(", ")}`);
+  if (body.summary !== void 0 && body.summary !== null && typeof body.summary !== "string")
+    return fail(400, "summary must be a string");
+  if (run3.status !== "active") return fail(409, `run ${run3.id} is already ${run3.status}`);
+  const loaded = loadSwarmConfig(ctx.root);
+  const caller = loaded.state === "ok" ? callerOf(loaded.config, {}) : { label: COORDINATOR };
+  try {
+    const r = finishRun(ctx, getStorage(ctx), run3, caller, {
+      status,
+      summary: typeof body.summary === "string" ? body.summary : void 0,
+      remember: body.remember === true
+    });
+    return ok({ run: r.run, memory: r.memory ?? null, memoryError: r.memoryError ?? null });
+  } catch (err) {
+    if (err instanceof SwarmError) return fail(409, err.message);
+    throw err;
+  }
+}
+function releaseSwarmWorker(ctx, body) {
+  const { run: run3, error: error62 } = runFromId(ctx, body.id);
+  if (error62 || !run3) return error62 ?? fail(400, "id required");
+  const agent = body.agent;
+  if (typeof agent !== "string" || !agent.trim() || agent.length > 200)
+    return fail(400, "agent must be a worker's agent id");
+  if (run3.status !== "active") return fail(409, `run ${run3.id} is already ${run3.status}`);
+  const loaded = loadSwarmConfig(ctx.root);
+  const caller = loaded.state === "ok" ? callerOf(loaded.config, {}) : { label: COORDINATOR };
+  try {
+    const released = releaseWorkers(getStorage(ctx), run3, caller, { agent });
+    if (!released.length) return fail(404, `no running worker ${agent.slice(0, 80)} in this run`);
+    return ok({ released: released.map((w) => w.agent_id) });
+  } catch (err) {
+    if (err instanceof SwarmError) return fail(409, err.message);
+    throw err;
+  }
+}
+async function swarmRoute(ctx, req) {
+  const { path: path3, method, query } = req;
+  const isGet = method === "GET" || method === "HEAD";
+  const readBody = async () => {
+    const b = await req.body();
+    return b && typeof b === "object" && !Array.isArray(b) ? b : {};
+  };
+  if (path3 === "/api/swarm") {
+    if (!isGet) return fail(405, "GET only");
+    return ok(swarmOverview(ctx, Number(query.get("limit")) || RUNS_LIMIT));
+  }
+  if (path3 === "/api/swarm/run") {
+    if (!isGet) return fail(405, "GET only");
+    const { run: run3, error: error62 } = runFromId(ctx, query.get("id"));
+    if (error62 || !run3) return error62 ?? fail(400, "id required");
+    const since = query.get("tasksSince");
+    if (since !== null && !/^\d{1,15}$/.test(since))
+      return fail(400, "tasksSince must be a non-negative integer (ms)");
+    return ok(
+      runDetail(ctx, run3, {
+        tasksSince: since === null ? void 0 : Number(since),
+        events: query.get("events") !== "0"
+      })
+    );
+  }
+  if (path3 === "/api/swarm/task") {
+    if (!isGet) return fail(405, "GET only");
+    const raw = query.get("id") ?? "";
+    if (!/^\d{1,15}$/.test(raw)) return fail(400, "id must be a task id");
+    const task = getStorage(ctx).swarm.taskGet(Number(raw));
+    const runId = query.get("run");
+    if (!task || runId && task.run_id !== runId) return fail(404, `task ${raw} not found`);
+    return ok({ task });
+  }
+  if (path3 === "/api/swarm/events") {
+    if (!isGet) return fail(405, "GET only");
+    const { run: run3, error: error62 } = runFromId(ctx, query.get("id"));
+    if (error62 || !run3) return error62 ?? fail(400, "id required");
+    const raw = query.get("after") ?? "0";
+    if (!/^\d{1,15}$/.test(raw)) return fail(400, "after must be a non-negative integer");
+    const events = getStorage(ctx).swarm.events(run3.id, {
+      after: Number(raw),
+      limit: EVENTS_PAGE
+    });
+    return ok({
+      run: { id: run3.id, status: run3.status, updated_at: run3.updated_at },
+      events,
+      last: events.length ? events[events.length - 1].id : Number(raw),
+      more: events.length === EVENTS_PAGE,
+      now: Date.now()
+    });
+  }
+  if (path3 === "/api/swarm/init") {
+    if (method !== "POST") return fail(405, "POST only");
+    return initSwarm(ctx);
+  }
+  if (path3 === "/api/swarm/sync") {
+    if (method !== "POST") return fail(405, "POST only");
+    return syncSwarm(ctx);
+  }
+  if (path3 === "/api/swarm/finish") {
+    if (method !== "POST") return fail(405, "POST only");
+    let body;
+    try {
+      body = await readBody();
+    } catch {
+      return fail(400, "invalid JSON body");
+    }
+    return finishSwarmRun(ctx, body);
+  }
+  if (path3 === "/api/swarm/release") {
+    if (method !== "POST") return fail(405, "POST only");
+    let body;
+    try {
+      body = await readBody();
+    } catch {
+      return fail(400, "invalid JSON body");
+    }
+    return releaseSwarmWorker(ctx, body);
+  }
+  return fail(404, "not found");
+}
+var RUN_ID_RE, SEGMENT_GAP_MS, EVENTS_PAGE, READ_PAGE, TIMELINE_EVENTS_MAX, SNAPSHOT_EVENTS, TASK_TEXT_MAX, TASKS_SINCE_OVERLAP_MS, RUNS_LIMIT, RUNS_LIMIT_MAX, FINISH_STATUSES, ok, fail, ioOf, clipText;
+var init_swarm_api = __esm({
+  "src/ui/swarm-api.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_storage();
+    init_agents();
+    init_config2();
+    init_runtime();
+    RUN_ID_RE = /^\d{8}-[0-9a-f]{6}$/;
+    SEGMENT_GAP_MS = 6e4;
+    EVENTS_PAGE = 200;
+    READ_PAGE = 1e3;
+    TIMELINE_EVENTS_MAX = 2e4;
+    SNAPSHOT_EVENTS = 200;
+    TASK_TEXT_MAX = 300;
+    TASKS_SINCE_OVERLAP_MS = 5e3;
+    RUNS_LIMIT = 30;
+    RUNS_LIMIT_MAX = 500;
+    FINISH_STATUSES = ["done", "failed", "cancelled"];
+    ok = (body) => ({ status: 200, body });
+    fail = (status, error62, extra = {}) => ({
+      status,
+      body: { error: error62, ...extra }
+    });
+    ioOf = (e) => {
+      const p = e.payload?.io;
+      if (p === "read" || p === "write" || p === "exec" || p === "swarm" || p === "other") return p;
+      const tool = e.payload?.tool;
+      if (typeof tool === "string") return toolIo(tool);
+      return e.kind === "tool" || e.kind === "tool_error" ? "other" : "swarm";
+    };
+    clipText = (s) => s !== null && s.length > TASK_TEXT_MAX ? s.slice(0, TASK_TEXT_MAX) : s;
+  }
+});
+
 // src/ui/server.ts
 var server_exports = {};
 __export(server_exports, {
@@ -48238,9 +50322,9 @@ __export(server_exports, {
   uiDir: () => uiDir
 });
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync28, readFileSync as readFileSync24, statSync as statSync12 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync26, statSync as statSync13 } from "fs";
 import { createServer } from "http";
-import { extname as extname3, join as join32, normalize as normalize6 } from "path";
+import { extname as extname3, join as join35, normalize as normalize7 } from "path";
 import { URL as URL2 } from "url";
 function json2(res, status, body) {
   res.writeHead(status, {
@@ -48262,18 +50346,18 @@ function strList(v) {
   return void 0;
 }
 function uiDir() {
-  return process.env.EMINIAR_UI_DIR || join32(pluginRoot(), "dist", "ui");
+  return process.env.EMINIAR_UI_DIR || join35(pluginRoot(), "dist", "ui");
 }
 function originAllowed(req, port) {
   const host = req.headers.host ?? "";
-  const ok = (h) => h === `127.0.0.1:${port}` || h === `localhost:${port}` || h === `[::1]:${port}`;
-  if (!ok(host)) return false;
+  const ok2 = (h) => h === `127.0.0.1:${port}` || h === `localhost:${port}` || h === `[::1]:${port}`;
+  if (!ok2(host)) return false;
   const method = req.method ?? "GET";
   if (method === "GET" || method === "HEAD") return true;
   const origin = req.headers.origin;
   if (origin) {
     try {
-      if (!ok(new URL2(origin).host)) return false;
+      if (!ok2(new URL2(origin).host)) return false;
     } catch {
       return false;
     }
@@ -48286,25 +50370,25 @@ function originAllowed(req, port) {
 function serveStatic(res, p) {
   const dir = uiDir();
   const rel = p === "/" ? "index.html" : p.replace(/^\/+/, "");
-  const file3 = normalize6(join32(dir, rel));
-  if (!file3.startsWith(normalize6(dir))) return false;
-  if (!existsSync28(file3) || !statSync12(file3).isFile()) return false;
+  const file3 = normalize7(join35(dir, rel));
+  if (!file3.startsWith(normalize7(dir))) return false;
+  if (!existsSync30(file3) || !statSync13(file3).isFile()) return false;
   const type = MIME[extname3(file3).toLowerCase()] ?? "application/octet-stream";
   if (rel === "index.html") {
     const stamp = (name) => {
       try {
-        return `/${name}?v=${Math.floor(statSync12(join32(dir, name)).mtimeMs)}`;
+        return `/${name}?v=${Math.floor(statSync13(join35(dir, name)).mtimeMs)}`;
       } catch {
         return `/${name}`;
       }
     };
-    const html = readFileSync24(file3, "utf8").replace('"/app.global.js"', `"${stamp("app.global.js")}"`).replace('"/styles.css"', `"${stamp("styles.css")}"`);
+    const html = readFileSync26(file3, "utf8").replace('"/app.global.js"', `"${stamp("app.global.js")}"`).replace('"/styles.css"', `"${stamp("styles.css")}"`);
     res.writeHead(200, { "content-type": type, "cache-control": "no-store" });
     res.end(html);
     return true;
   }
   res.writeHead(200, { "content-type": type, "cache-control": "no-cache" });
-  res.end(readFileSync24(file3));
+  res.end(readFileSync26(file3));
   return true;
 }
 async function serve(opts) {
@@ -48671,6 +50755,10 @@ async function serve(opts) {
         if (!isUsageSessionId(id)) return json2(res, 400, { error: "invalid session id" });
         return json2(res, 200, usageSessionPayload(ctx(), id, { calls: q.get("calls") === "1" }));
       }
+      if (p === "/api/swarm" || p.startsWith("/api/swarm/")) {
+        const r = await swarmRoute(ctx(), { path: p, method, query: q, body: () => readJson4(req) });
+        return json2(res, r.status, r.body);
+      }
       if (p === "/api/events")
         return json2(
           res,
@@ -48697,9 +50785,9 @@ async function serve(opts) {
       json2(res, 500, { error: err.message });
     }
   });
-  await new Promise((resolve9, reject) => {
+  await new Promise((resolve11, reject) => {
     server.once("error", reject);
-    server.listen(opts.port, "127.0.0.1", resolve9);
+    server.listen(opts.port, "127.0.0.1", resolve11);
   });
   const url2 = `http://127.0.0.1:${opts.port}/`;
   console.log(`eminiar dashboard at ${url2} (Ctrl-C to stop)`);
@@ -48720,6 +50808,7 @@ var init_server = __esm({
     init_history_api();
     init_history_graph_api();
     init_knowledge_api();
+    init_swarm_api();
     MIME = {
       ".html": "text/html; charset=utf-8",
       ".js": "text/javascript; charset=utf-8",
@@ -48737,13 +50826,832 @@ var init_server = __esm({
   }
 });
 
+// src/swarm/format.ts
+function ago2(ts, now = Date.now()) {
+  if (!ts) return "n/a";
+  const s = Math.max(0, Math.round((now - ts) / 1e3));
+  if (s < 90) return `${s}s ago`;
+  if (s < 5400) return `${Math.round(s / 60)}m ago`;
+  if (s < 48 * 3600) return `${Math.round(s / 3600)}h ago`;
+  return `${Math.round(s / 86400)}d ago`;
+}
+function capOutput(s, max = OUTPUT_MAX, hint) {
+  if (s.length <= max) return s;
+  const room = max - 120;
+  const cut = s.lastIndexOf("\n", room);
+  const head = s.slice(0, cut > room / 2 ? cut : room);
+  return `${head}
+\u2026 ${s.length - head.length} more characters left out${hint ? `; ${hint}` : ""}`;
+}
+function shortAgent(agentId) {
+  return agentId.replace(/^agent-/, "").slice(0, 8);
+}
+function holderName(agentId, workers) {
+  if (!agentId) return "n/a";
+  const w = workers.get(agentId);
+  if (w) return `${w.role}@${shortAgent(agentId)}`;
+  return agentId;
+}
+function eventWho(e) {
+  if (e.agent_id) return `${e.role ?? "worker"}@${shortAgent(e.agent_id)}`;
+  return e.role ?? "n/a";
+}
+function formatIssues(rel, issues) {
+  return issues.map((i) => `${rel}${i.line ? `:${i.line}` : ""}${i.path ? ` ${i.path}` : ""}: ${i.message}`).join("\n");
+}
+function formatInvalid(rel, issues) {
+  return capOutput(
+    `${rel} has ${issues.length} problem(s); swarms stay off until it validates (\`eminiar swarm validate\`):
+${formatIssues(rel, issues)}`
+  );
+}
+function formatNotOptedIn(rel) {
+  return [
+    `Agent swarms are opt-in and this project has not opted in (no ${rel}).`,
+    "To enable them, ask the user to run `eminiar swarm init` (writes a starter file and generates the worker agents), use \u201CCreate starter swarm.yaml\u201D on the Swarms tab of the dashboard (`eminiar ui`), or write the file by hand (https://github.com/rydn/eminiar/blob/main/docs/swarms.md).",
+    "Until then, do not improvise a swarm: use ordinary subagents or do the work directly."
+  ].join("\n");
+}
+function runListItem(run3, tasks, workers) {
+  return {
+    run: run3,
+    done: tasks.filter((t) => t.status === "done").length,
+    total: tasks.length,
+    running: workers.filter((w) => w.status === "running").length
+  };
+}
+function runLine(r, now, sessionId) {
+  const { run: run3 } = r;
+  return `${RUN_GLYPH[run3.status]} ${run3.id} ${run3.swarm} ${run3.status}${sessionId && run3.session_id === sessionId ? " (this session)" : ""} \xB7 tasks ${r.done}/${r.total} done \xB7 ${r.running} running \xB7 started ${ago2(run3.created_at, now)}${run3.status === "active" ? ` \xB7 updated ${ago2(run3.updated_at, now)}` : ` \xB7 ended ${ago2(run3.ended_at, now)}`} \u2014 ${clip3(firstLine3(run3.goal), 100)}`;
+}
+function runRef(run3) {
+  return `${run3.id} (${run3.swarm}) "${clip3(firstLine3(run3.goal), 80)}"`;
+}
+function enforceNote(config2) {
+  if (!config2.enabled || !config2.enforce) return "";
+  return ` \xB7 enforce on${config2.allowedAgents.length ? ` (also allowed: ${config2.allowedAgents.join(", ")})` : ""}`;
+}
+function formatSwarmList(config2, plan, active, opts = {}) {
+  const now = opts.now ?? Date.now();
+  const byAgent2 = new Map(plan.map((a) => [a.agentType, a]));
+  const counts = /* @__PURE__ */ new Map();
+  for (const a of plan) counts.set(a.action, (counts.get(a.action) ?? 0) + 1);
+  const fileSummary = [...counts].map(([action, n]) => `${n} ${SYNC_STATE[action]}`).join(", ");
+  const swarms = opts.swarm ? config2.swarms.filter((s) => s.name === opts.swarm) : config2.swarms;
+  const lines = [
+    `eminiar swarms \xB7 ${config2.rel} \xB7 sync ${config2.sync}${enforceNote(config2)} \xB7 agent files: ${fileSummary || "none"}`
+  ];
+  if (opts.swarm && !swarms.length)
+    lines.push(
+      `No swarm "${opts.swarm}"; ${config2.rel} defines: ${config2.swarms.map((s) => s.name).join(", ")}`
+    );
+  for (const s of swarms) {
+    lines.push(
+      "",
+      `${s.name} \xB7 ${s.topology} \xB7 up to ${s.maxAgents} worker(s) at once \u2014 ${clip3(s.description, 160)}`
+    );
+    if (s.topology === "pipeline" && s.stages.length)
+      lines.push(`  stages: ${s.stages.join(" \u2192 ")}`);
+    for (const r of s.roles) {
+      const state = byAgent2.get(r.agentType);
+      lines.push(
+        `  ${r.role} \u2192 ${r.agentType} \xB7 ${r.model ?? "inherit"} \xB7 \xD7${r.count}${r.isolation ? " \xB7 worktree" : ""} \xB7 ${state ? SYNC_STATE[state.action] : "n/a"}${state?.action === "conflict" ? ` (${state.reason ?? state.path})` : ""}`
+      );
+    }
+  }
+  const leftover = plan.filter((a) => a.action === "delete");
+  if (leftover.length)
+    lines.push(
+      "",
+      `Left-over agent files: ${leftover.map((a) => a.path).join(", ")} (${leftover[0]?.reason ?? "not in the swarm file"})`
+    );
+  if (plan.some((a) => a.action === "create" || a.action === "update" || a.action === "delete"))
+    lines.push(
+      'Agent files differ from the YAML: em_swarm {action:"sync"} (or `eminiar swarm sync`).'
+    );
+  if (plan.some((a) => a.action === "conflict"))
+    lines.push(
+      "Sync leaves conflicts alone: rename the role or the hand-written file; for a generated file edited by hand, move the edit into the YAML or overwrite it with sync --force."
+    );
+  lines.push("");
+  if (active.length) {
+    lines.push("Active runs:");
+    for (const r of active.slice(0, 10)) lines.push(`  ${runLine(r, now, opts.sessionId)}`);
+  } else lines.push("No active run.");
+  lines.push(
+    'Start one: em_swarm {action:"start", swarm, goal}; the em-swarm skill has the coordinator playbook.'
+  );
+  return capOutput(lines.join("\n"));
+}
+function formatRunList(items2, now = Date.now()) {
+  if (!items2.length) return "No swarm runs yet.";
+  return capOutput(items2.map((r) => runLine(r, now)).join("\n"));
+}
+function formatSync2(result, opts = {}) {
+  const word = (a) => SYNC_VERB[a][opts.dryRun ? "dry" : "done"];
+  const tally = /* @__PURE__ */ new Map();
+  for (const a of result.actions) tally.set(a.action, (tally.get(a.action) ?? 0) + 1);
+  const head = `${opts.dryRun ? "dry run \xB7 " : ""}agent files (.claude/agents): ${result.actions.length ? [...tally].map(([a, n]) => `${n} ${word(a)}`).join(", ") : "nothing to do"}${opts.reason ? ` (${opts.reason})` : ""}`;
+  const lines = [head];
+  for (const a of result.actions) {
+    if (a.action === "unchanged") continue;
+    lines.push(
+      `  ${SYNC_VERB[a.action].mark} ${word(a.action)} ${a.path}${a.reason ? `: ${a.reason}` : ""}`
+    );
+  }
+  if (!opts.dryRun && result.actions.some((a) => a.action === "create"))
+    lines.push(
+      "Claude Code reads agent files when a session starts: if a new worker type is not available yet, open /agents or restart the session."
+    );
+  return capOutput(lines.join("\n"));
+}
+function quietHolder(t, workers) {
+  if (t.status !== "active" || !t.agent_id) return void 0;
+  const w = workers.get(t.agent_id);
+  return w && (w.status === "stale" || w.status === "done") ? w : void 0;
+}
+function taskLine(t, byId, workers, now) {
+  const parts = [`#${t.id} ${clip3(t.title, 120)}${t.role ? ` (${t.role})` : ""}`];
+  if (t.agent_id && t.status !== "pending") parts.push(holderName(t.agent_id, workers));
+  if (t.status === "pending") {
+    const waiting = t.deps.filter((d) => byId.get(d)?.status !== "done");
+    if (waiting.length) parts.push(`waits on ${waiting.map((d) => `#${d}`).join(", ")}`);
+  }
+  if (t.files.length && (t.status === "pending" || t.status === "active"))
+    parts.push(
+      `files ${t.files.slice(0, 3).join(", ")}${t.files.length > 3 ? ` +${t.files.length - 3}` : ""}`
+    );
+  let line = parts.join(" \xB7 ");
+  const quiet = quietHolder(t, workers);
+  if (quiet?.status === "stale")
+    line += ` \xB7 \u26A0 holder quiet ${Math.max(1, Math.round((now - quiet.last_ts) / 6e4))}m \u2014 release with em_swarm {action:"release", agent:"${shortAgent(quiet.agent_id)}"} or update status:pending`;
+  else if (quiet)
+    line += ` \xB7 \u26A0 holder stopped \u2014 reopen with em_swarm {action:"update", task:${t.id}, status:"pending"}`;
+  if (t.auto_closed) line += " \xB7 \u26A0 auto-closed: the worker never reported; check the result";
+  if (t.result && t.status !== "active" && t.status !== "pending")
+    line += ` \u2014 ${clip3(firstLine3(t.result), 140)}`;
+  return line;
+}
+function workerLine(w, now) {
+  const when = w.status === "done" ? `ended ${ago2(w.ended_at, now)}` : `last seen ${ago2(w.last_ts, now)}`;
+  return [
+    `${WORKER_GLYPH[w.status]} ${w.status} ${w.role}@${shortAgent(w.agent_id)}`,
+    w.task_id !== null ? `task #${w.task_id}` : void 0,
+    `${w.tool_calls} tool call(s)${w.errors ? `, ${w.errors} failed` : ""}`,
+    `last ${w.last_tool ?? "n/a"}`,
+    when
+  ].filter(Boolean).join(" \xB7 ").concat(w.status === "done" && w.summary ? ` \u2014 ${clip3(firstLine3(w.summary), 120)}` : "");
+}
+function eventLine(e, now) {
+  return `  ${ago2(e.ts, now)} ${eventWho(e)} ${e.kind}${e.task_id !== null ? ` #${e.task_id}` : ""}${e.text ? ` ${clip3(firstLine3(e.text), 140)}` : ""}`;
+}
+function nextStep(snap) {
+  if (snap.run.status !== "active") return void 0;
+  const t = snap.counts.tasks;
+  const open3 = t.pending + t.active + t.blocked;
+  const running2 = snap.counts.workers.running;
+  const stale = snap.counts.staleHeld;
+  const hints = [];
+  if (stale)
+    hints.push(
+      `${stale} active task(s) are held by a worker that went quiet or stopped: em_swarm {action:"release"} frees every quiet worker (agent or role picks one), or reopen a task with em_swarm {action:"update", task, status:"pending"}.`
+    );
+  if (snap.counts.autoClosed)
+    hints.push(
+      `${snap.counts.autoClosed} task(s) were auto-closed; check them and reopen with em_swarm {action:"update", task, status:"pending"} if the work is not done.`
+    );
+  if (!snap.tasks.length)
+    hints.push('No tasks yet: em_swarm {action:"plan", tasks:[{title, role, files, deps}]}.');
+  else if (!open3)
+    hints.push(
+      'Every task is closed: review the results, then em_swarm {action:"finish", status:"done", summary, remember:true}.'
+    );
+  else if (!running2 && t.active <= stale && t.pending)
+    hints.push(
+      'No worker is running: spawn workers for the claimable tasks (Agent tool, a prompt naming "task #N"; the worker claims it).'
+    );
+  if (t.blocked)
+    hints.push(`${t.blocked} task(s) blocked: read their results and unblock or re-plan.`);
+  return hints.length ? `Next: ${hints.join(" ")}` : void 0;
+}
+function formatRunStatus(snap, opts = {}) {
+  const now = opts.now ?? Date.now();
+  const perGroup = opts.perGroup ?? PER_GROUP;
+  const maxWorkers = opts.workers ?? 12;
+  const { run: run3 } = snap;
+  const workers = new Map(
+    [...snap.holders ?? [], ...snap.workers].map((w) => [w.agent_id, w])
+  );
+  const byId = new Map(snap.tasks.map((t) => [t.id, t]));
+  const c = snap.counts;
+  const lines = [
+    `Run ${run3.id} \xB7 swarm "${run3.swarm}" (${run3.topology}) \xB7 ${RUN_GLYPH[run3.status]} ${run3.status} \xB7 started ${ago2(run3.created_at, now)} \xB7 ${run3.status === "active" ? `updated ${ago2(run3.updated_at, now)}` : `ended ${ago2(run3.ended_at, now)}`}`,
+    ...opts.lead ?? [],
+    `Goal: ${clip3(run3.goal, 400)}`
+  ];
+  if (run3.summary) lines.push(`Summary: ${clip3(run3.summary, 600)}`);
+  const next = nextStep(snap);
+  if (next) lines.push(next);
+  const taskTally = GROUP_ORDER.filter((s) => c.tasks[s]).map((s) => `${c.tasks[s]} ${s}`);
+  if (c.staleHeld) taskTally.push(`${c.staleHeld} held by a quiet worker`);
+  lines.push("", `Tasks (${snap.tasks.length}): ${taskTally.join(" \xB7 ") || "none planned"}`);
+  for (const status of GROUP_ORDER) {
+    const group = snap.tasks.filter((t) => t.status === status).sort(
+      (a, b) => Number(!!quietHolder(b, workers)) - Number(!!quietHolder(a, workers)) || Number(b.auto_closed) - Number(a.auto_closed) || a.id - b.id
+    );
+    if (!group.length) continue;
+    lines.push(`${TASK_GLYPH[status]} ${status}`);
+    for (const t of group.slice(0, perGroup)) lines.push(`  ${taskLine(t, byId, workers, now)}`);
+    if (group.length > perGroup) lines.push(`  \u2026 ${group.length - perGroup} more ${status}`);
+  }
+  const wt = ["running", "stale", "done"].filter((s) => c.workers[s]).map((s) => `${c.workers[s]} ${s}`);
+  lines.push(
+    "",
+    `Workers (${snap.workers.length}): ${wt.join(" \xB7 ") || "none spawned"}${snap.workers.length ? ` \xB7 ${c.toolCalls} tool call(s), ${c.errors} failed` : ""}`
+  );
+  const rank = { running: 0, stale: 1, done: 2 };
+  const shown = [...snap.workers].sort(
+    (a, b) => rank[a.status] - rank[b.status] || b.last_ts - a.last_ts
+  );
+  for (const w of shown.slice(0, maxWorkers)) lines.push(`  ${workerLine(w, now)}`);
+  if (shown.length > maxWorkers) lines.push(`  \u2026 ${shown.length - maxWorkers} more worker(s)`);
+  if (snap.notes.length)
+    lines.push(
+      "",
+      `Blackboard (em_swarm {action:"read", key}): ${snap.notes.slice(0, 16).map((n) => `${n.key} (${n.author ?? "n/a"}, v${n.version}, ${ago2(n.ts, now)})`).join(" \xB7 ")}${snap.notes.length > 16 ? ` \xB7 \u2026 ${snap.notes.length - 16} more` : ""}`
+    );
+  const events = snap.events.slice(-(opts.events ?? 12));
+  if (events.length) {
+    lines.push("", "Recent events (oldest first):");
+    for (const e of events) lines.push(eventLine(e, now));
+  }
+  return capOutput(
+    lines.join("\n"),
+    opts.max ?? OUTPUT_MAX,
+    `\`eminiar swarm status ${run3.id}\` prints all of it`
+  );
+}
+function formatReleased(run3, released, running2, opts, now = Date.now()) {
+  if (released.length)
+    return `Released ${released.length} worker(s) of run ${run3.id}: ${released.map(
+      (w) => `${w.role}@${shortAgent(w.agent_id)}${w.task_id !== null ? ` (task #${w.task_id} back to pending)` : ""}`
+    ).join(
+      ", "
+    )}. They no longer count against capacity; spawn a worker for each reopened task (a prompt naming "task #N").`;
+  const why = opts.agent ? `no running worker's id starts with "${opts.agent}"` : opts.role ? `no ${opts.role} worker is running` : `no running worker has been quiet for ${opts.staleMinutes} minutes`;
+  const live2 = running2.length ? ` Running: ${running2.slice(0, 8).map((w) => `${w.role}@${shortAgent(w.agent_id)} (last seen ${ago2(w.last_ts, now)})`).join(
+    ", "
+  )}${running2.length > 8 ? ", \u2026" : ""}; name one with agent:"<id>" or role:"<role>".` : " No worker of the run is running.";
+  return `Nothing released in run ${run3.id}: ${why}.${live2}`;
+}
+function watchStep(prevKey, snap, lastEvent) {
+  const last = lastEvent !== void 0 ? lastEvent : [...snap.events].reverse().find((e) => isWatchEvent(e)) ?? null;
+  const body = {
+    run: snap.run.id,
+    swarm: snap.run.swarm,
+    status: snap.run.status,
+    tasks: { ...snap.counts.tasks },
+    workers: { ...snap.counts.workers },
+    auto_closed: snap.counts.autoClosed,
+    stale_held: snap.counts.staleHeld,
+    last_event: last ? {
+      id: last.id,
+      kind: last.kind,
+      who: eventWho(last),
+      task: last.task_id,
+      text: last.text ? clip3(firstLine3(last.text), 160) : null
+    } : null
+  };
+  const key = JSON.stringify({
+    status: body.status,
+    tasks: body.tasks,
+    workers: body.workers,
+    auto_closed: body.auto_closed,
+    stale_held: body.stale_held,
+    event: last?.id ?? null
+  });
+  if (snap.run.status !== "active") return { key, line: { type: "swarm.finished", ...body } };
+  if (prevKey === void 0) return { key, line: { type: "swarm.snapshot", ...body } };
+  if (key === prevKey) return { key };
+  const idle = body.workers.running === 0 && body.tasks.active <= body.stale_held;
+  return { key, line: { type: idle ? "swarm.idle" : "swarm.changed", ...body } };
+}
+var OUTPUT_MAX, TASK_GLYPH, WORKER_GLYPH, RUN_GLYPH, firstLine3, SYNC_STATE, SYNC_VERB, GROUP_ORDER, PER_GROUP, WATCH_EVENT_KINDS, isWatchEvent;
+var init_format3 = __esm({
+  "src/swarm/format.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_runtime();
+    OUTPUT_MAX = 6e3;
+    TASK_GLYPH = {
+      pending: "\u25CB",
+      active: "\u25CF",
+      blocked: "\u25C6",
+      done: "\u2713",
+      failed: "\u2717"
+    };
+    WORKER_GLYPH = {
+      running: "\u25CF",
+      done: "\u2713",
+      stale: "\u25CC"
+    };
+    RUN_GLYPH = {
+      active: "\u25CF",
+      done: "\u2713",
+      failed: "\u2717",
+      cancelled: "\u25CC"
+    };
+    firstLine3 = (s) => s.trim().split("\n")[0] ?? "";
+    SYNC_STATE = {
+      unchanged: "synced",
+      create: "not generated",
+      update: "out of date",
+      delete: "left over",
+      conflict: "conflict"
+    };
+    SYNC_VERB = {
+      create: { done: "created", dry: "to create", mark: "+" },
+      update: { done: "updated", dry: "to update", mark: "~" },
+      delete: { done: "deleted", dry: "to delete", mark: "-" },
+      unchanged: { done: "unchanged", dry: "unchanged", mark: "=" },
+      conflict: { done: "conflict", dry: "conflict", mark: "!" }
+    };
+    GROUP_ORDER = ["active", "blocked", "failed", "pending", "done"];
+    PER_GROUP = 12;
+    WATCH_EVENT_KINDS = /* @__PURE__ */ new Set([
+      "run_start",
+      "plan",
+      "claim",
+      "update",
+      "post",
+      "start",
+      "stop",
+      "auto_close",
+      "deny",
+      "run_finish"
+    ]);
+    isWatchEvent = (e) => WATCH_EVENT_KINDS.has(e.kind);
+  }
+});
+
+// src/hooks/log.ts
+import { appendFileSync } from "fs";
+var init_log2 = __esm({
+  "src/hooks/log.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_paths();
+  }
+});
+
+// src/session/brief.ts
+import { existsSync as existsSync31, readFileSync as readFileSync27 } from "fs";
+import { join as join36 } from "path";
+var init_brief2 = __esm({
+  "src/session/brief.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_manifest();
+    init_model();
+    init_frontmatter();
+    init_store();
+  }
+});
+
+// src/swarm/brief.ts
+var init_brief3 = __esm({
+  "src/swarm/brief.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_model();
+    init_brief2();
+    init_recall();
+    init_glob();
+    init_runtime();
+  }
+});
+
+// src/swarm/identity.ts
+import { createHmac, randomBytes as randomBytes2, timingSafeEqual } from "crypto";
+import { mkdirSync as mkdirSync14, readFileSync as readFileSync28, writeFileSync as writeFileSync12 } from "fs";
+import { join as join37 } from "path";
+var init_identity = __esm({
+  "src/swarm/identity.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_paths();
+  }
+});
+
+// src/swarm/hooks.ts
+import { execFileSync } from "child_process";
+import { readFileSync as readFileSync29, realpathSync as realpathSync4, statSync as statSync14 } from "fs";
+import { basename as basename3, dirname as dirname13, join as join38, resolve as resolve10 } from "path";
+function coordinationRoot(root) {
+  try {
+    const dotGit = join38(root, ".git");
+    if (!statSync14(dotGit).isFile()) return root;
+    const m = /^gitdir:\s*(.+?)\s*$/m.exec(readFileSync29(dotGit, "utf8"));
+    if (!m) return root;
+    const gitdir = resolve10(root, m[1]);
+    let common;
+    try {
+      common = resolve10(gitdir, readFileSync29(join38(gitdir, "commondir"), "utf8").trim());
+    } catch {
+      return root;
+    }
+    if (basename3(common) === ".git") return realpathSync4(dirname13(common));
+    const out = execFileSync("git", ["worktree", "list", "--porcelain"], {
+      cwd: root,
+      encoding: "utf8",
+      timeout: 2e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const first = /^worktree (.+)$/m.exec(out)?.[1];
+    if (!first || /^bare$/m.test(out.split("\n\n")[0] ?? "")) return root;
+    const main = realpathSync4(first);
+    return main !== realpathSync4(common) && statSync14(join38(main, ".git"), { throwIfNoEntry: false }) ? main : root;
+  } catch {
+    return root;
+  }
+}
+var init_hooks = __esm({
+  "src/swarm/hooks.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_context();
+    init_log2();
+    init_project();
+    init_storage();
+    init_agents();
+    init_brief3();
+    init_config2();
+    init_identity();
+    init_runtime();
+  }
+});
+
+// src/swarm/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  SWARM_USAGE: () => SWARM_USAGE,
+  swarmCommand: () => swarmCommand
+});
+import { mkdirSync as mkdirSync15, writeFileSync as writeFileSync13 } from "fs";
+import { dirname as dirname14 } from "path";
+import { parseArgs } from "util";
+async function storage(ctx) {
+  const { getStorage: getStorage2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
+  return getStorage2(ctx, { vectors: false });
+}
+function items(db, runs) {
+  const now = Date.now();
+  return runs.map(
+    (r) => runListItem(
+      r,
+      db.swarm.tasks(r.id),
+      db.swarm.workers(r.id).map((w) => ({ ...w, status: workerStatus(w, now) }))
+    )
+  );
+}
+async function swarmCommand(args, callerCtx, io = defaultIO, opts = {}) {
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      force: { type: "boolean" },
+      "dry-run": { type: "boolean" },
+      json: { type: "boolean" },
+      limit: { type: "string" },
+      run: { type: "string" },
+      interval: { type: "string" },
+      agent: { type: "string" },
+      role: { type: "string" }
+    },
+    allowPositionals: true,
+    strict: false
+  });
+  const [sub = "list", arg] = positionals;
+  const json3 = !!values.json;
+  for (const name of VALUE_OPTIONS)
+    if (values[name] === true) {
+      io.err(`--${name} needs a value`);
+      return 2;
+    }
+  const opt = (name) => {
+    const v = values[name];
+    return typeof v === "string" ? v : void 0;
+  };
+  const root = coordinationRoot(callerCtx.root);
+  const ctx = root === callerCtx.root ? callerCtx : getContext(root);
+  const emit = (v) => io.out(JSON.stringify(v, null, 2));
+  switch (sub) {
+    case "init": {
+      const where = swarmFile(root);
+      if (where.exists && !values.force) {
+        io.err(`${where.rel} already exists; pass --force to overwrite it with the starter file`);
+        return 1;
+      }
+      mkdirSync15(dirname14(where.file), { recursive: true });
+      writeFileSync13(where.file, STARTER_YAML);
+      const loaded = loadSwarmConfig(root);
+      if (loaded.state !== "ok") {
+        io.err(`${where.rel} was written but does not validate`);
+        return 1;
+      }
+      const r = syncAgents(root, loaded.config);
+      if (json3) {
+        emit({ file: where.rel, swarms: loaded.config.swarms.map((s) => s.name), sync: r });
+        return r.conflicts ? 1 : 0;
+      }
+      io.out(
+        [
+          `wrote ${where.rel} (swarms: ${loaded.config.swarms.map((s) => s.name).join(", ")})`,
+          formatSync2(r),
+          "Edit the file to fit the project, then in Claude Code: /eminiar:em-swarm feature <goal>",
+          "Docs: https://github.com/rydn/eminiar/blob/main/docs/swarms.md"
+        ].join("\n")
+      );
+      return r.conflicts ? 1 : 0;
+    }
+    case "validate": {
+      const loaded = loadSwarmConfig(root);
+      if (json3) {
+        emit(
+          loaded.state === "ok" ? {
+            state: "ok",
+            file: loaded.config.rel,
+            enabled: loaded.config.enabled,
+            enforce: loaded.config.enforce,
+            allowed_agents: loaded.config.allowedAgents,
+            swarms: loaded.config.swarms.map((s) => s.name)
+          } : loaded.state === "invalid" ? {
+            state: "invalid",
+            file: loaded.rel,
+            enforce: loaded.enforce ?? false,
+            issues: loaded.issues
+          } : { state: "absent", file: loaded.rel }
+        );
+        return loaded.state === "ok" ? 0 : 1;
+      }
+      if (loaded.state === "absent") {
+        io.err(`no ${loaded.rel}: swarms are off in this project (eminiar swarm init creates one)`);
+        return 1;
+      }
+      if (loaded.state === "invalid") {
+        io.err(formatIssues(loaded.rel, loaded.issues));
+        return 1;
+      }
+      const c = loaded.config;
+      io.out(
+        `ok: ${c.rel} \xB7 ${c.swarms.length} swarm(s), ${c.swarms.reduce((n, s) => n + s.roles.length, 0)} role(s)${c.enabled ? "" : " \xB7 disabled (enabled: false)"}${enforceNote(c)}`
+      );
+      return 0;
+    }
+    case "sync": {
+      const loaded = loadSwarmConfig(root);
+      const dryRun = !!values["dry-run"];
+      if (loaded.state === "invalid") {
+        if (json3)
+          emit({
+            dryRun,
+            reason: `${loaded.rel} is invalid: swarms stay off and sync changes nothing`,
+            file: loaded.rel,
+            issues: loaded.issues,
+            actions: [],
+            changed: 0,
+            conflicts: 0
+          });
+        else io.err(formatInvalid(loaded.rel, loaded.issues));
+        return 1;
+      }
+      const config2 = loaded.state === "ok" ? loaded.config : void 0;
+      const syncOpts = { dryRun, force: !!values.force };
+      const r = syncAgents(root, config2, syncOpts);
+      const reason = loaded.state === "absent" ? `no ${loaded.rel}: swarms are off` : config2?.enabled ? void 0 : "swarms are disabled";
+      if (json3) emit({ dryRun, reason: reason ?? null, ...r });
+      else io.out(formatSync2(r, { dryRun, reason }));
+      return r.conflicts ? 1 : 0;
+    }
+    case "list": {
+      const loaded = loadSwarmConfig(root);
+      if (loaded.state === "absent") {
+        if (json3) emit({ state: "absent", file: loaded.rel });
+        else io.out(formatNotOptedIn(loaded.rel));
+        return 0;
+      }
+      if (loaded.state === "invalid") {
+        if (json3) emit({ state: "invalid", file: loaded.rel, issues: loaded.issues });
+        else io.err(formatInvalid(loaded.rel, loaded.issues));
+        return 1;
+      }
+      const c = loaded.config;
+      const plan = planAgentSync(root, c).map(({ content: _c, ...a }) => a);
+      const db = await storage(ctx);
+      const active = items(db, db.swarm.runs({ status: "active", limit: 10 }));
+      if (json3) {
+        emit({
+          state: "ok",
+          file: c.rel,
+          enabled: c.enabled,
+          sync: c.sync,
+          swarms: c.swarms.map((s) => ({
+            name: s.name,
+            description: s.description,
+            topology: s.topology,
+            max_agents: s.maxAgents,
+            stages: s.stages,
+            roles: s.roles.map((r) => ({
+              role: r.role,
+              subagent_type: r.agentType,
+              model: r.model ?? null,
+              count: r.count,
+              file: plan.find((a) => a.agentType === r.agentType)?.action ?? null
+            }))
+          })),
+          agent_files: plan,
+          active_runs: active
+        });
+        return 0;
+      }
+      io.out(
+        `${c.enabled ? "" : "(disabled: enabled is false, workers cannot be spawned)\n"}${formatSwarmList(c, plan, active)}`
+      );
+      return 0;
+    }
+    case "runs": {
+      const limit = opt("limit") === void 0 ? 20 : Number(opt("limit"));
+      if (!Number.isInteger(limit) || limit < 1) {
+        io.err("--limit must be a positive integer");
+        return 2;
+      }
+      const db = await storage(ctx);
+      const list2 = items(db, db.swarm.runs({ limit: Math.min(limit, 500) }));
+      if (json3) emit(list2);
+      else io.out(formatRunList(list2));
+      return 0;
+    }
+    case "status": {
+      const db = await storage(ctx);
+      const id = arg ?? opt("run");
+      const run3 = id ? db.swarm.runGet(id) : db.swarm.runActive() ?? db.swarm.runs({ limit: 1 })[0];
+      if (!run3) {
+        io.err(id ? `unknown run "${id}"` : "no swarm runs yet");
+        return 1;
+      }
+      const snap = runSnapshot(db, run3);
+      if (json3) {
+        emit(snap);
+        return 0;
+      }
+      const others = id ? [] : db.swarm.runs({ status: "active", limit: 50 }).filter((r) => r.id !== run3.id);
+      io.out(
+        formatRunStatus(snap, {
+          max: Number.POSITIVE_INFINITY,
+          perGroup: Number.POSITIVE_INFINITY,
+          workers: Number.POSITIVE_INFINITY,
+          lead: others.length ? [
+            `Also active: ${others.slice(0, 5).map(runRef).join("; ")}${others.length > 5 ? "; \u2026" : ""} (eminiar swarm status <run>)`
+          ] : []
+        })
+      );
+      return 0;
+    }
+    case "release": {
+      const db = await storage(ctx);
+      const id = opt("run") ?? arg;
+      let run3;
+      if (id) {
+        run3 = db.swarm.runGet(id);
+        if (!run3) {
+          io.err(`unknown run "${id}"`);
+          return 1;
+        }
+      } else {
+        const active = db.swarm.runs({ status: "active", limit: 50 });
+        if (active.length > 1) {
+          io.err(
+            `${active.length} runs are active; pass --run: ${active.slice(0, 8).map(runRef).join("; ")}`
+          );
+          return 1;
+        }
+        run3 = active[0];
+        if (!run3) {
+          io.err("no active swarm run; pass --run to release workers of a finished one");
+          return 1;
+        }
+      }
+      const agent = opt("agent")?.trim() || void 0;
+      const role = opt("role")?.trim() || void 0;
+      try {
+        const released = releaseWorkers(db, run3, { label: COORDINATOR }, { agent, role });
+        const running2 = db.swarm.workers(run3.id).filter((w) => w.status === "running");
+        if (json3)
+          emit({
+            run: run3.id,
+            released: released.map((w) => ({
+              agent_id: w.agent_id,
+              role: w.role,
+              task_id: w.task_id
+            }))
+          });
+        else
+          io.out(
+            formatReleased(run3, released, running2, {
+              agent,
+              role,
+              staleMinutes: Math.round(STALE_MS / 6e4)
+            })
+          );
+        return 0;
+      } catch (err) {
+        if (!(err instanceof SwarmError)) throw err;
+        io.err(err.message);
+        return 1;
+      }
+    }
+    case "watch": {
+      const interval = opt("interval") === void 0 ? 2 : Number(opt("interval"));
+      if (!Number.isFinite(interval) || interval <= 0) {
+        io.err("--interval must be a positive number of seconds");
+        return 2;
+      }
+      const db = await storage(ctx);
+      const id = opt("run") ?? arg;
+      const first = id ? db.swarm.runGet(id) : db.swarm.runActive();
+      if (!first) {
+        io.err(
+          id ? `unknown run "${id}"` : 'no active swarm run to watch; start one with em_swarm {action:"start", swarm, goal} or pass --run'
+        );
+        return 1;
+      }
+      if (!id) {
+        const others = db.swarm.runs({ status: "active", limit: 50 }).length - 1;
+        if (others > 0)
+          io.err(
+            `watching run ${first.id}; ${others} other run(s) are active (pass --run to pick)`
+          );
+      }
+      let lastSeen = 0;
+      let lastEvent = null;
+      const scan = (rows) => {
+        for (const e of rows) {
+          lastSeen = Math.max(lastSeen, e.id);
+          if (isWatchEvent(e)) lastEvent = e;
+        }
+        return rows.length;
+      };
+      scan(db.swarm.events(first.id, { limit: WATCH_PAGE }));
+      let key;
+      for (let tick = 0; ; tick++) {
+        const run3 = db.swarm.runGet(first.id);
+        if (!run3) {
+          io.err(`run ${first.id} disappeared`);
+          return 1;
+        }
+        for (let n = WATCH_PAGE; tick > 0 && n === WATCH_PAGE; )
+          n = scan(db.swarm.events(run3.id, { after: lastSeen, limit: WATCH_PAGE }));
+        const step = watchStep(key, runSnapshot(db, run3, 0), lastEvent);
+        key = step.key;
+        if (step.line) io.out(JSON.stringify(step.line));
+        if (run3.status !== "active") return 0;
+        if (opts.maxTicks !== void 0 && tick + 1 >= opts.maxTicks) return 0;
+        await sleep(Math.max(250, interval * 1e3));
+      }
+    }
+    default:
+      io.err(SWARM_USAGE);
+      return 2;
+  }
+}
+var defaultIO, SWARM_USAGE, sleep, VALUE_OPTIONS, WATCH_PAGE;
+var init_cli = __esm({
+  "src/swarm/cli.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_context();
+    init_agents();
+    init_config2();
+    init_format3();
+    init_hooks();
+    init_runtime();
+    defaultIO = {
+      out: (s) => console.log(s),
+      err: (s) => console.error(s)
+    };
+    SWARM_USAGE = "usage: eminiar swarm <init [--force] | validate | sync [--dry-run] [--force] | list | runs [--limit N] | status [run] | release [--run id] [--agent id] [--role r] | watch [--run id] [--interval 2]> [--json]";
+    sleep = (ms) => new Promise((resolve11) => setTimeout(resolve11, ms));
+    VALUE_OPTIONS = ["limit", "run", "interval", "agent", "role"];
+    WATCH_PAGE = 1e3;
+  }
+});
+
 // src/stats/statusline.ts
 var statusline_exports = {};
 __export(statusline_exports, {
   renderStatusline: () => renderStatusline,
   usageSegments: () => usageSegments
 });
-import { existsSync as existsSync29, readFileSync as readFileSync25, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync30, writeFileSync as writeFileSync14 } from "fs";
 function epochMs(v) {
   if (typeof v === "number" && Number.isFinite(v)) return v < 1e12 ? v * 1e3 : v;
   if (typeof v === "string") {
@@ -48803,10 +51711,10 @@ function renderStatusline(raw) {
   } catch {
   }
   const key = cacheKey(input2);
-  const cache3 = paths().statuslineCache;
+  const cache5 = paths().statuslineCache;
   try {
-    if (existsSync29(cache3)) {
-      const c = JSON.parse(readFileSync25(cache3, "utf8"));
+    if (existsSync32(cache5)) {
+      const c = JSON.parse(readFileSync30(cache5, "utf8"));
       if (Date.now() - c.at < CACHE_TTL_MS && c.key === key) return c.line;
     }
   } catch {
@@ -48837,7 +51745,7 @@ function renderStatusline(raw) {
     line = `eminiar \xB7 unavailable (${err.message.slice(0, 40)})`;
   }
   try {
-    writeFileSync10(cache3, JSON.stringify({ at: Date.now(), line, key }));
+    writeFileSync14(cache5, JSON.stringify({ at: Date.now(), line, key }));
   } catch {
   }
   return line;
@@ -48865,7 +51773,7 @@ init_esm_shims();
 init_context();
 init_doctor();
 init_version();
-import { parseArgs } from "util";
+import { parseArgs as parseArgs2 } from "util";
 var USAGE = `eminiar v${version2()} \u2014 local-first context, memory & knowledge graph for Claude Code
 
 Usage: eminiar <command> [options]
@@ -48905,13 +51813,24 @@ Use
   statusline                   Claude Code statusLine command (reads JSON on stdin)
   hook [--event E] [--client claude|cursor]   Run the hook handler manually (reads JSON on stdin)
   version | help
+
+Agent swarms (opt-in: .eminiar/swarm.yaml)
+  swarm init [--force]         Write a starter swarm.yaml and generate the worker agents
+  swarm validate               Check swarm.yaml; exit 1 with file:line messages on problems
+  swarm sync [--dry-run] [--force]   Regenerate .claude/agents/swarm-*.md from swarm.yaml;
+                               --force also overwrites generated files edited by hand
+  swarm list | runs [--limit N] | status [run]   Swarms and roles, past runs, one run (in full)
+  swarm release [--run id] [--agent id] [--role r]   Free stuck workers (default: every worker
+                               quiet for 15 min); their tasks go back to pending
+  swarm watch [--run id] [--interval 2]          One NDJSON line per change (for the Monitor
+                               tool); exits when the run finishes. --json on the others
 `;
 function text2(r) {
   return r.content.map((c) => c.text).join("\n");
 }
 var commands = {
   async doctor(args) {
-    const { values } = parseArgs({
+    const { values } = parseArgs2({
       args,
       options: { json: { type: "boolean" }, fix: { type: "boolean" } },
       strict: false
@@ -48923,7 +51842,7 @@ var commands = {
     return checks.every((c) => c.ok) ? 0 : 1;
   },
   async install(args) {
-    const { values } = parseArgs({
+    const { values } = parseArgs2({
       args,
       options: {
         "no-model": { type: "boolean" },
@@ -48957,7 +51876,7 @@ var commands = {
     return upgrade2();
   },
   async uninstall(args) {
-    const { values } = parseArgs({
+    const { values } = parseArgs2({
       args,
       options: { "purge-data": { type: "boolean" }, yes: { type: "boolean" } },
       strict: false
@@ -48966,7 +51885,7 @@ var commands = {
     return uninstall2({ purgeData: !!values["purge-data"], yes: !!values.yes });
   },
   async "replace-context-mode"(args) {
-    const { values } = parseArgs({
+    const { values } = parseArgs2({
       args,
       options: { yes: { type: "boolean" }, "revert-gateway": { type: "boolean" } },
       strict: false
@@ -48975,7 +51894,7 @@ var commands = {
     return replaceContextMode2({ yes: !!values.yes, revertGateway: !!values["revert-gateway"] });
   },
   async index(args) {
-    const { values, positionals } = parseArgs({
+    const { values, positionals } = parseArgs2({
       args,
       options: { source: { type: "string" }, glob: { type: "string", multiple: true } },
       allowPositionals: true,
@@ -48995,7 +51914,7 @@ var commands = {
     return r.isError ? 1 : 0;
   },
   async search(args) {
-    const { values, positionals } = parseArgs({
+    const { values, positionals } = parseArgs2({
       args,
       options: {
         source: { type: "string" },
@@ -49047,7 +51966,7 @@ var commands = {
     return 0;
   },
   async graph(args) {
-    const { values, positionals } = parseArgs({
+    const { values, positionals } = parseArgs2({
       args,
       options: { to: { type: "string" }, depth: { type: "string" }, limit: { type: "string" } },
       allowPositionals: true,
@@ -49107,7 +52026,7 @@ var commands = {
     return r.isError ? 1 : 0;
   },
   async reindex(args) {
-    const { values } = parseArgs({
+    const { values } = parseArgs2({
       args,
       options: { scope: { type: "string" }, full: { type: "boolean" } },
       strict: false
@@ -49121,7 +52040,7 @@ var commands = {
     return 0;
   },
   async docs(args) {
-    const { values, positionals } = parseArgs({
+    const { values, positionals } = parseArgs2({
       args,
       options: {
         dev: { type: "boolean" },
@@ -49175,7 +52094,7 @@ var commands = {
     return r.isError ? 1 : 0;
   },
   async stats(args) {
-    const { values } = parseArgs({
+    const { values } = parseArgs2({
       args,
       options: { lifetime: { type: "boolean" } },
       strict: false
@@ -49186,7 +52105,7 @@ var commands = {
     return 0;
   },
   async usage(args) {
-    const { values, positionals } = parseArgs({
+    const { values, positionals } = parseArgs2({
       args,
       options: {
         since: { type: "string" },
@@ -49258,7 +52177,7 @@ var commands = {
     return r.isError ? 1 : 0;
   },
   async recall(args) {
-    const { values, positionals } = parseArgs({
+    const { values, positionals } = parseArgs2({
       args,
       options: {
         explain: { type: "boolean" },
@@ -49303,7 +52222,7 @@ var commands = {
     return 0;
   },
   async purge(args) {
-    const { values, positionals } = parseArgs({
+    const { values, positionals } = parseArgs2({
       args,
       options: { yes: { type: "boolean" } },
       allowPositionals: true,
@@ -49322,7 +52241,7 @@ var commands = {
   },
   /** `eminiar ui` opens the browser by default; `serve` (the older name) does not. */
   async ui(args) {
-    const { values } = parseArgs({
+    const { values } = parseArgs2({
       args,
       options: {
         port: { type: "string" },
@@ -49340,7 +52259,7 @@ var commands = {
     return 0;
   },
   async serve(args) {
-    const { values } = parseArgs({
+    const { values } = parseArgs2({
       args,
       options: { port: { type: "string" }, open: { type: "boolean" } },
       strict: false
@@ -49353,6 +52272,10 @@ var commands = {
     });
     return 0;
   },
+  async swarm(args) {
+    const { swarmCommand: swarmCommand2 } = await Promise.resolve().then(() => (init_cli(), cli_exports));
+    return swarmCommand2(args, getContext());
+  },
   async statusline() {
     const { renderStatusline: renderStatusline2 } = await Promise.resolve().then(() => (init_statusline(), statusline_exports));
     const chunks = [];