@wrenautomation/aerie 0.6.1 → 0.7.1

package/dist/bin.js

@@ -1233,7 +1233,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str2)]);
       }
       sql2.raw = raw;
-      function join7(chunks, separator) {
+      function join8(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) {
@@ -1243,7 +1243,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      sql2.join = join7;
+      sql2.join = join8;
       function identifier(value) {
         return new Name(value);
       }
@@ -5521,7 +5521,7 @@ var init_select2 = __esm({
           const baseTableName = this.tableName;
           const tableName = getTableLikeName(table);
           for (const item of extractUsedTable(table)) this.usedTables.add(item);
-          if (typeof tableName === "string" && this.config.joins?.some((join7) => join7.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins?.some((join8) => join8.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (!this.isPartialSelect) {
@@ -7048,7 +7048,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return (table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join7) => join7.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins.some((join8) => join8.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (typeof on === "function") {
@@ -7144,10 +7144,10 @@ var init_update = __esm({
               const fromFields = this.getTableLikeFields(this.config.from);
               fields[tableName] = fromFields;
             }
-            for (const join7 of this.config.joins) {
-              const tableName2 = getTableLikeName(join7.table);
-              if (typeof tableName2 === "string" && !is(join7.table, SQL)) {
-                const fromFields = this.getTableLikeFields(join7.table);
+            for (const join8 of this.config.joins) {
+              const tableName2 = getTableLikeName(join8.table);
+              if (typeof tableName2 === "string" && !is(join8.table, SQL)) {
+                const fromFields = this.getTableLikeFields(join8.table);
                 fields[tableName2] = fromFields;
               }
             }
@@ -8801,7 +8801,9 @@ var init_schema2 = __esm({
         /** taken from the queue: where release(queue) puts it back */
         queued: boolean4().notNull().default(false),
         lane: text2(),
-        pin: text2()
+        pin: text2(),
+        /** the take's own key: a replayed take with it gets this lease back, not the next row */
+        takeKey: text2("take_key")
       },
       (t) => [primaryKey({ columns: [t.ns, t.taskId, t.holder], name: "pk_coord_lease" })]
     );
@@ -8951,7 +8953,7 @@ function aerieStore(o) {
     return (r[0]?.v ?? o.prefix ?? "T").toUpperCase();
   }
   const rules = o.rules ?? WREN_RULES;
-  async function write(by, fn) {
+  async function write2(by, fn) {
     const out = await atomic(db, async (tx) => {
       await o.hooks?.onWrite?.(tx, by);
       return fn(tx);
@@ -9111,7 +9113,7 @@ function aerieStore(o) {
     return rows3.map(viewOf);
   }
   async function saveView(owner, v) {
-    const id = await write(owner, async (tx) => {
+    const id = await write2(owner, async (tx) => {
       await ensureActors(tx, [owner]);
       const set3 = {
         filter: v.filter,
@@ -9126,7 +9128,7 @@ function aerieStore(o) {
     return { id, ...v };
   }
   async function deleteView(owner, name) {
-    const r = await write(
+    const r = await write2(
       owner,
       (tx) => tx.delete(view).where(and(eq(view.owner, owner), eq(view.name, name))).returning({ id: view.id })
     );
@@ -9164,7 +9166,7 @@ function aerieStore(o) {
       throw new AerieError(`recommendation ${d.recommendation} is not an option`);
     const blocks = [];
     for (const b of d.blocks ?? []) blocks.push((await must(b, db)).id);
-    const id = await write(by, async (tx) => {
+    const id = await write2(by, async (tx) => {
       const [r] = await tx.insert(decision).values({
         question: d.question,
         options: d.options,
@@ -9187,7 +9189,7 @@ function aerieStore(o) {
     const [d] = await decisions({ ids: [id] });
     if (!d) throw new AerieError(`no decision ${id}`, 404);
     if (d.answeredAt) throw new AerieError(`decision ${id} is answered (${d.answer})`, 409);
-    await write(by, async (tx) => {
+    await write2(by, async (tx) => {
       await tx.update(decision).set({ answer, answeredBy: by, answeredAt: now(), why: why ?? null }).where(and(eq(decision.id, id), isNull2(decision.answeredAt)));
     });
     const opt = d.options.find((x) => x.key === answer);
@@ -9217,7 +9219,7 @@ function aerieStore(o) {
       recommendation: d.recommendation,
       why: p.why
     };
-    await write(by, async (tx) => {
+    await write2(by, async (tx) => {
       await tx.update(decision).set({
         ...p.brief !== void 0 ? { brief: p.brief } : {},
         ...p.recommendation !== void 0 ? { recommendation: p.recommendation } : {},
@@ -9248,7 +9250,7 @@ function aerieStore(o) {
         ...drop.flatMap((id) => all.find((x) => x.id === id)?.blocks ?? [])
       ])
     ];
-    await write(by, async (tx) => {
+    await write2(by, async (tx) => {
       await tx.update(decision).set({ blocks }).where(eq(decision.id, keep));
       await tx.update(decision).set({
         answer: "merged",
@@ -9386,7 +9388,7 @@ function aerieStore(o) {
     return `${base}${max + 1}`;
   }
   async function create(input2, by, opts = {}) {
-    const id = await write(by, async (tx) => {
+    const id = await write2(by, async (tx) => {
       const parent = input2.parentId ? await must(input2.parentId, tx) : null;
       if (input2.milestone)
         input2 = { ...input2, milestone: await milestoneOf(tx, input2.milestone) };
@@ -9417,7 +9419,7 @@ function aerieStore(o) {
     return must(id, db);
   }
   async function edit(id, e, by, opts = {}) {
-    const done = await write(by, async (tx) => {
+    const done = await write2(by, async (tx) => {
       const row = await lockRow(tx, id);
       if (opts.expect !== void 0 && opts.expect !== row.version)
         throw new AerieError(`stale: ${row.id} is at version ${row.version}`, 409);
@@ -9435,7 +9437,7 @@ function aerieStore(o) {
   }
   async function importTasks(tasks, by) {
     const out = { added: [], changed: [], same: 0 };
-    await write(by, async (tx) => {
+    await write2(by, async (tx) => {
       const have = new Map((await load2(tx)).map((t) => [t.id, t]));
       for (const { task: task2, place, expect } of tasks) {
         if (expect !== void 0) {
@@ -9471,7 +9473,7 @@ function aerieStore(o) {
     })).sort((a, b) => a.path < b.path ? -1 : 1);
   }
   async function addArea(path2, by, p = {}) {
-    await write(by, async (tx) => {
+    await write2(by, async (tx) => {
       const id = await ensureArea(tx, path2);
       const set3 = {
         ...p.name ? { name: p.name } : {},
@@ -9488,13 +9490,13 @@ function aerieStore(o) {
     return all.filter((a) => roots.some((r) => a.path === r || a.path.startsWith(`${r}/`))).map((a) => a.path);
   }
   async function grant(area2, actor2, role, by) {
-    await write(by, async (tx) => {
+    await write2(by, async (tx) => {
       await ensureActors(tx, [actor2]);
       await tx.insert(areaRole).values({ areaId: await areaIdOf(tx, area2), actorId: actor2, role }).onConflictDoNothing();
     });
   }
   async function revoke(area2, actor2, role, by) {
-    await write(by, async (tx) => {
+    await write2(by, async (tx) => {
       const areaId = await areaIdOf(tx, area2);
       await tx.delete(areaRole).where(
         and(
@@ -9528,7 +9530,7 @@ function aerieStore(o) {
     return r[0]?.id ?? null;
   }
   async function setActor(id, p, by) {
-    await write(by, async (tx) => {
+    await write2(by, async (tx) => {
       await ensureActors(tx, [id]);
       const set3 = {
         ...p.name ? { name: p.name } : {},
@@ -9547,7 +9549,7 @@ function aerieStore(o) {
     return r[0]?.v ?? null;
   }
   async function setSetting(key, value, by, onlyIfUnset = false) {
-    await write(by, async (tx) => {
+    await write2(by, async (tx) => {
       const q = tx.insert(setting).values({ key, value });
       await (onlyIfUnset ? q.onConflictDoNothing() : q.onConflictDoUpdate({ target: setting.key, set: { value } }));
     });
@@ -9584,7 +9586,7 @@ function aerieStore(o) {
   }
   async function putMilestones(ms2, by) {
     if (!ms2.length) return;
-    await write(by, async (tx) => {
+    await write2(by, async (tx) => {
       for (const m of ms2)
         await tx.insert(milestone).values({ id: m.id, title: m.title, description: m.description ?? null }).onConflictDoUpdate({
           target: milestone.id,
@@ -9610,7 +9612,7 @@ function aerieStore(o) {
   }
   async function addRouteRule(r, by) {
     if (r.runner === "session" && !r.lane) throw new AerieError("a session rule needs a lane");
-    return write(by, async (tx) => {
+    return write2(by, async (tx) => {
       await ensureActors(tx, [by]);
       const [last] = await tx.select({ rank: routeRule.rank }).from(routeRule).orderBy(sql`${routeRule.rank} desc`).limit(1);
       const [row] = await tx.insert(routeRule).values({
@@ -9627,14 +9629,14 @@ function aerieStore(o) {
     });
   }
   async function removeRouteRule(id, by) {
-    return write(by, async (tx) => {
+    return write2(by, async (tx) => {
       const r = await tx.delete(routeRule).where(eq(routeRule.id, id)).returning({ id: routeRule.id });
       return r.length > 0;
     });
   }
   async function log(taskId, by, kind, body, why) {
     const t = await must(taskId, db);
-    await write(by, async (tx) => {
+    await write2(by, async (tx) => {
       await ensureActors(tx, [by]);
       await event(tx, t.id, by, kind, body, why);
     });
@@ -10262,6 +10264,7 @@ var init_pglite = __esm({
 // src/coord/postgres.ts
 var postgres_exports = {};
 __export(postgres_exports, {
+  COORD_CHANNEL: () => COORD_CHANNEL,
   pgCoord: () => pgCoord
 });
 async function rows2(q, query) {
@@ -10296,7 +10299,7 @@ function pgCoord(o) {
     if (!hit[0] || hit[0].status === name) return;
     await aerieStore({ db: tx }).edit(id, { status: name }, by);
   };
-  const lease = async (tx, id, holder, leaseMs, queued) => {
+  const lease = async (tx, id, holder, leaseMs, queued, key) => {
     const t = clock();
     const others = await rows2(
       tx,
@@ -10309,9 +10312,10 @@ function pgCoord(o) {
     );
     const gen = num(g?.gen);
     await tx.execute(sql`
-      insert into ${L} (ns, task_id, holder, gen, expires, queued, lane, pin)
-      values (${ns}, ${id}, ${holder}, ${gen}, ${plus(t, leaseMs)}, ${!!queued}, ${queued?.lane ?? null}, ${queued?.pin ?? null})
+      insert into ${L} (ns, task_id, holder, gen, expires, queued, lane, pin, take_key)
+      values (${ns}, ${id}, ${holder}, ${gen}, ${plus(t, leaseMs)}, ${!!queued}, ${queued?.lane ?? null}, ${queued?.pin ?? null}, ${key ?? null})
       on conflict (ns, task_id, holder) do update set gen = excluded.gen, expires = excluded.expires,
+        take_key = coalesce(excluded.take_key, ${L}.take_key),
         queued = excluded.queued or ${L}.queued,
         lane = case when excluded.queued then excluded.lane else ${L}.lane end,
         pin = case when excluded.queued then excluded.pin else ${L}.pin end`);
@@ -10363,7 +10367,9 @@ function pgCoord(o) {
   };
   const queueRows = (q) => rows2(
     q,
-    sql`select task_id as id, lane, pin, pos from ${Q} where ns = ${ns} order by pos, task_id`
+    sql`select q.task_id as id, q.lane, q.pin, q.pos, k.title from ${Q} q
+          left join ${task} k on k.id = upper(q.task_id)
+          where q.ns = ${ns} order by q.pos, q.task_id`
   );
   const store = {
     name: "aerie",
@@ -10498,10 +10504,54 @@ function pgCoord(o) {
       await tx.execute(sql`delete from ${Q} where ns = ${ns} and task_id = any(${textArr(ids)})`);
     }),
     queueList: async () => (await queueRows(db)).map(
-      (i, pos) => ({ id: i.id, lane: i.lane, pin: i.pin, pos })
+      (i, pos) => ({
+        id: i.id,
+        lane: i.lane,
+        pin: i.pin,
+        pos,
+        ...i.title ? { title: i.title } : {}
+      })
     ),
     queueTake: (x, holder, leaseMs) => atomic(db, async (tx) => {
       await lockQueue(tx);
+      if (x.key) {
+        const [had] = await rows2(
+          tx,
+          sql`select task_id as id, gen::float8 as gen from ${L} where ns = ${ns} and holder = ${holder}
+                and take_key = ${x.key} and expires >= ${clock()}`
+        );
+        if (had) return { id: had.id, gen: num(had.gen) };
+      }
+      if (x.pin?.startsWith("run:")) {
+        const t = clock();
+        const lapsed = await rows2(
+          tx,
+          sql`select task_id as id, holder, queued from ${L}
+                where ns = ${ns} and pin = ${x.pin} and expires < ${t} order by task_id`
+        );
+        if (lapsed.length) {
+          await lockTasks(
+            tx,
+            lapsed.map((l) => l.id)
+          );
+          for (const l of lapsed) {
+            const still = await rows2(
+              tx,
+              sql`select 1 from ${L} where ns = ${ns} and task_id = ${l.id} and holder = ${l.holder}
+                    and expires < ${t}`
+            );
+            if (still.length) await drop(tx, l.id, [l.holder], { queue: l.queued, by: l.holder });
+          }
+        }
+        if (x.cap !== void 0) {
+          const [n] = await rows2(
+            tx,
+            sql`select count(*)::int as n from ${L}
+                  where ns = ${ns} and pin = ${x.pin} and expires >= ${t}`
+          );
+          if (num(n?.n) >= x.cap) return null;
+        }
+      }
       const all = x.lanes === "*";
       const lanes = Array.isArray(x.lanes) ? x.lanes : [];
       const [item] = await rows2(
@@ -10514,7 +10564,14 @@ function pgCoord(o) {
       if (!item) return null;
       await lockTasks(tx, [item.id]);
       await tx.execute(sql`delete from ${Q} where ns = ${ns} and task_id = ${item.id}`);
-      const r = await lease(tx, item.id, holder, leaseMs, { lane: item.lane, pin: item.pin });
+      const r = await lease(
+        tx,
+        item.id,
+        holder,
+        leaseMs,
+        { lane: item.lane, pin: item.pin },
+        x.key
+      );
       return { id: item.id, gen: r.gen };
     }),
     fence: async (id, holder, gen) => (await rows2(
@@ -10526,9 +10583,18 @@ function pgCoord(o) {
       await o.end?.();
     }
   };
+  const sub = o.subscribe;
+  if (sub)
+    store.listen = async (onChange) => {
+      const stop = await sub(COORD_CHANNEL, (payload) => {
+        const [what, ...rest] = payload.split(":");
+        if (rest.join(":") === ns && (what === "queue" || what === "lease")) onChange(what);
+      });
+      return { end: stop };
+    };
   return store;
 }
-var ms, at2, num, textArr;
+var COORD_CHANNEL, ms, at2, num, textArr;
 var init_postgres = __esm({
   "src/coord/postgres.ts"() {
     "use strict";
@@ -10536,6 +10602,7 @@ var init_postgres = __esm({
     init_db2();
     init_schema2();
     init_store();
+    COORD_CHANNEL = "aerie_coord";
     ms = (v) => sql`(extract(epoch from ${v}) * 1000)::float8`;
     at2 = (v) => sql`to_timestamp(${v}::float8 / 1000)`;
     num = (v) => Math.round(Number(v));
@@ -10558,9 +10625,9 @@ __export(setup_exports, {
 });
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { createHash as createHash2, createHmac, pbkdf2Sync, randomBytes } from "node:crypto";
-import { chmodSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join5 } from "node:path";
+import { chmodSync, existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname3, join as join6 } from "node:path";
 function aerieUrl(adminUrl, role = ROLE) {
   const url2 = new URL(adminUrl);
   if (!url2.password) throw new Error("admin URL has no password; aerie derives its own from it");
@@ -10615,10 +10682,10 @@ function adminUrlFromSsm(param, key, region) {
   throw new Error(`${key} not in ${param} (or its -2, -3 parts)`);
 }
 function writeSettings(set3, file2 = settingsFile()) {
-  const lines = existsSync4(file2) ? readFileSync4(file2, "utf8").split("\n").filter(Boolean) : [];
+  const lines = existsSync5(file2) ? readFileSync5(file2, "utf8").split("\n").filter(Boolean) : [];
   const kept = lines.filter((l) => !Object.keys(set3).some((k) => l.startsWith(`${k}=`)));
-  mkdirSync2(dirname2(file2), { recursive: true, mode: 448 });
-  writeFileSync2(
+  mkdirSync3(dirname3(file2), { recursive: true, mode: 448 });
+  writeFileSync3(
     file2,
     `${[...kept, ...Object.entries(set3).map(([k, v]) => `${k}=${v}`)].join("\n")}
 `,
@@ -10656,14 +10723,14 @@ var init_setup = __esm({
     ROLE = "aerie";
     SCHEMA = "aerie";
     ATTRS = "LOGIN NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT NOREPLICATION NOBYPASSRLS";
-    settingsFile = () => join5(homedir2(), ".config", "aerie", "env");
+    settingsFile = () => join6(homedir3(), ".config", "aerie", "env");
   }
 });
 
 // src/bin.ts
-import { readFileSync as readFileSync5 } from "node:fs";
-import { homedir as homedir3, userInfo } from "node:os";
-import { join as join6 } from "node:path";
+import { readFileSync as readFileSync6 } from "node:fs";
+import { homedir as homedir4, userInfo } from "node:os";
+import { join as join7 } from "node:path";
 
 // node_modules/.pnpm/commander@15.0.0/node_modules/commander/lib/error.js
 var CommanderError = class extends Error {
@@ -11840,7 +11907,7 @@ var Command = class _Command extends EventEmitter {
     this._outputConfiguration = {
       writeOut: (str2) => process2.stdout.write(str2),
       writeErr: (str2) => process2.stderr.write(str2),
-      outputError: (str2, write) => write(str2),
+      outputError: (str2, write2) => write2(str2),
       getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : void 0,
       getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : void 0,
       getOutHasColors: () => useColor() ?? (process2.stdout.isTTY && process2.stdout.hasColors?.()),
@@ -13825,11 +13892,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
       hasColors = this._outputConfiguration.getOutHasColors();
       helpWidth = this._outputConfiguration.getOutHelpWidth();
     }
-    const write = (str2) => {
+    const write2 = (str2) => {
       if (!hasColors) str2 = this._outputConfiguration.stripColor(str2);
       return baseWrite(str2);
     };
-    return { error: error62, write, hasColors, helpWidth };
+    return { error: error62, write: write2, hasColors, helpWidth };
   }
   /**
    * Output help information for this command.
@@ -37652,7 +37719,7 @@ function visit(schema2, fnOrHandlers) {
     return h ? h(node2, rewritten) : node2;
   };
   const cache = /* @__PURE__ */ new Map();
-  function run(s) {
+  function run2(s) {
     const cached2 = cache.get(s);
     if (cached2 === RESOLVING) {
       return new $ZodLazy({
@@ -37678,21 +37745,21 @@ function visit(schema2, fnOrHandlers) {
         let changed = false;
         const newShape = {};
         for (const k of keys) {
-          const mapped = run(oldShape[k]);
+          const mapped = run2(oldShape[k]);
           if (mapped !== oldShape[k])
             changed = true;
           newShape[k] = mapped;
         }
         let newCatchall = def.catchall;
         if (def.catchall) {
-          newCatchall = run(def.catchall);
+          newCatchall = run2(def.catchall);
           if (newCatchall !== def.catchall)
             changed = true;
         }
         return changed ? clone(s, { ...def, shape: newShape, catchall: newCatchall }) : s;
       }
       case "array": {
-        const mapped = run(def.element);
+        const mapped = run2(def.element);
         return mapped === def.element ? s : clone(s, { ...def, element: mapped });
       }
       case "tuple": {
@@ -37700,14 +37767,14 @@ function visit(schema2, fnOrHandlers) {
         let changed = false;
         const newItems = [];
         for (const item of oldItems) {
-          const mapped = run(item);
+          const mapped = run2(item);
           if (mapped !== item)
             changed = true;
           newItems.push(mapped);
         }
         let newRest = def.rest;
         if (def.rest) {
-          newRest = run(def.rest);
+          newRest = run2(def.rest);
           if (newRest !== def.rest)
             changed = true;
         }
@@ -37715,12 +37782,12 @@ function visit(schema2, fnOrHandlers) {
       }
       case "record":
       case "map": {
-        const newKey = run(def.keyType);
-        const newVal = run(def.valueType);
+        const newKey = run2(def.keyType);
+        const newVal = run2(def.valueType);
         return newKey === def.keyType && newVal === def.valueType ? s : clone(s, { ...def, keyType: newKey, valueType: newVal });
       }
       case "set": {
-        const newVal = run(def.valueType);
+        const newVal = run2(def.valueType);
         return newVal === def.valueType ? s : clone(s, { ...def, valueType: newVal });
       }
       case "union": {
@@ -37728,7 +37795,7 @@ function visit(schema2, fnOrHandlers) {
         let changed = false;
         const newOptions = [];
         for (const opt of oldOptions) {
-          const mapped = run(opt);
+          const mapped = run2(opt);
           if (mapped !== opt)
             changed = true;
           newOptions.push(mapped);
@@ -37736,8 +37803,8 @@ function visit(schema2, fnOrHandlers) {
         return changed ? clone(s, { ...def, options: newOptions }) : s;
       }
       case "intersection": {
-        const newLeft = run(def.left);
-        const newRight = run(def.right);
+        const newLeft = run2(def.left);
+        const newRight = run2(def.right);
         return newLeft === def.left && newRight === def.right ? s : clone(s, { ...def, left: newLeft, right: newRight });
       }
       case "optional":
@@ -37749,23 +37816,23 @@ function visit(schema2, fnOrHandlers) {
       case "nonoptional":
       case "promise":
       case "success": {
-        const newInner = run(def.innerType);
+        const newInner = run2(def.innerType);
         return newInner === def.innerType ? s : clone(s, { ...def, innerType: newInner });
       }
       case "pipe": {
-        const newIn = run(def.in);
-        const newOut = run(def.out);
+        const newIn = run2(def.in);
+        const newOut = run2(def.out);
         return newIn === def.in && newOut === def.out ? s : clone(s, { ...def, in: newIn, out: newOut });
       }
       case "function": {
-        const newInput = run(def.input);
-        const newOutput = run(def.output);
+        const newInput = run2(def.input);
+        const newOutput = run2(def.output);
         return newInput === def.input && newOutput === def.output ? s : clone(s, { ...def, input: newInput, output: newOutput });
       }
       case "lazy": {
         const original = def.getter;
         const { _cachedInner, ...rest } = def;
-        return clone(s, { ...rest, getter: () => run(original()) });
+        return clone(s, { ...rest, getter: () => run2(original()) });
       }
       // A leaf by choice: `parts` are regex fragments, not data positions.
       case "template_literal":
@@ -37796,7 +37863,7 @@ function visit(schema2, fnOrHandlers) {
       }
     }
   }
-  return run(schema2);
+  return run2(schema2);
 }
 
 // node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/deep-partial.js
@@ -37951,12 +38018,17 @@ async function routeOf(a, t, pick2) {
   };
 }
 var queueSpot = (r) => r.runner === "session" ? { lane: r.lane } : { lane: r.lane, pin: r.lane };
-async function route(a, coord, id, by, pick2) {
+var direct = (a, c) => (fn) => fn(a, c);
+async function route(a, coord, id, by, pick2, atomic2 = direct(a, coord)) {
   const t = await a.get(id);
   if (!t) throw new AerieError(`no task ${id}`, 404);
   const r = await routeOf(a, t, pick2);
+  await atomic2((a2, coord2) => write(a2, coord2, t.id, r, by));
+  return r;
+}
+async function write(a, coord, id, r, by) {
   await a.log(
-    t.id,
+    id,
     by,
     "routed",
     {
@@ -37968,11 +38040,10 @@ async function route(a, coord, id, by, pick2) {
     },
     r.why
   );
-  await coord.queueAdd([t.id], queueSpot(r));
-  return r;
+  await coord.queueAdd([id], queueSpot(r));
 }
 var RUN_FAILED = "Run failed";
-async function afterDecision(a, coord, d, by, pick2) {
+async function afterDecision(a, coord, d, by, pick2, atomic2 = direct(a, coord)) {
   const out = [];
   const worker = d.kind === "run-failed";
   for (const id of d.blocks) {
@@ -37982,16 +38053,18 @@ async function afterDecision(a, coord, d, by, pick2) {
       await a.edit(t.id, { assignees: ["@william"] }, by, { why: `decision ${d.id}` });
       out.push({ id: t.id, lane: null });
     } else if (worker && d.answer === "session") {
-      await a.log(
-        t.id,
-        by,
-        "routed",
-        { runner: "session", model: null, lane: t.area, rule: null },
-        `decision ${d.id}`
-      );
-      await coord.queueAdd([t.id], { lane: t.area });
+      await atomic2(async (a2, coord2) => {
+        await a2.log(
+          t.id,
+          by,
+          "routed",
+          { runner: "session", model: null, lane: t.area, rule: null },
+          `decision ${d.id}`
+        );
+        await coord2.queueAdd([t.id], { lane: t.area });
+      });
       out.push({ id: t.id, lane: t.area });
-    } else out.push({ id: t.id, lane: (await route(a, coord, t.id, by, pick2)).lane });
+    } else out.push({ id: t.id, lane: (await route(a, coord, t.id, by, pick2, atomic2)).lane });
   }
   return out;
 }
@@ -38097,12 +38170,12 @@ async function hear(file2, o = {}) {
   const { hearSpeech, speechHere } = await import("@wrenautomation/read/video");
   const { mkdtemp: mkdtemp2, rm } = await import("node:fs/promises");
   const { tmpdir: tmpdir2 } = await import("node:os");
-  const { join: join7 } = await import("node:path");
+  const { join: join8 } = await import("node:path");
   const cohere = (process.env.COHERE_API_KEY ?? "").split(",").filter(Boolean);
   const ear = speechHere(cohere);
   if (!ear)
     throw new AerieError("no ear: install whisper.cpp and its model, or set COHERE_API_KEY");
-  const dir = await mkdtemp2(join7(tmpdir2(), "aerie-hear-"));
+  const dir = await mkdtemp2(join8(tmpdir2(), "aerie-hear-"));
   const t0 = performance.now();
   try {
     const text3 = await hearSpeech(file2, dir, o.ffmpeg ?? "ffmpeg", ear, {
@@ -38280,7 +38353,7 @@ async function intake(a, input2, by, o = {}) {
           });
         else
           try {
-            const r = await route(a, o.coord, id, by, o.pick);
+            const r = await route(a, o.coord, id, by, o.pick, o.atomic);
             res.routed.push({ id, runner: r.runner, lane: r.lane });
           } catch (e) {
             res.routed.push({ id, runner: null, lane: null, error: e.message });
@@ -38319,12 +38392,12 @@ function plain(r) {
 `;
 }
 function registerIntakeCommands(program3, ctx) {
-  const either = (fn) => ctx.withBoard ? ctx.withBoard((a, c) => fn(a, c)) : ctx.withStore((a) => fn(a, null));
+  const either = (fn) => ctx.withBoard ? ctx.withBoard(fn) : ctx.withStore((a) => fn(a, null));
   program3.command("intake").argument("[words...]", "what to file; or --file, --audio, --into").description("words \u2192 tasks: split, checked (spans, missed words, areas, duplicates), filed").option("--file <path>", "the words from a file").option("--audio <path>", "a voice memo: heard by local whisper in 60 s clips").option("--kind <kind>", "text | chat | voice (default: voice with --audio, else text)").option(
     "--split <file>",
     "your own split as JSON ({tasks: [{title, span, why, area?}]}); - = stdin"
   ).option("--into <id>", "the intake a 'Split intake' task waits on").option("--area <path>", "area for tasks whose split names none").option("--why <text>", "why this intake").option("--dry-run", "split and check, file nothing").option("--route", "route each filed task").option("--json", "JSON out").action(
-    (words, o) => either(async (a, c) => {
+    (words, o) => either(async (a, c, atomic2) => {
       const text3 = o.file ? await readFile(o.file, "utf8") : words.join(" ");
       const split = o.split === void 0 ? void 0 : JSON.parse(o.split === "-" ? await stdin() : await readFile(o.split, "utf8"));
       const spec = await a.getSetting("router_model");
@@ -38346,6 +38419,7 @@ function registerIntakeCommands(program3, ctx) {
           model: await a.getSetting("intake_model") || void 0,
           lane: await a.getSetting("intake_lane") || "main",
           coord: c ?? void 0,
+          atomic: atomic2,
           pick: spec ? modelPicker(spec) : void 0
         }
       );
@@ -38407,11 +38481,181 @@ function aerieEnv(env = process.env) {
   return (k) => env[k] ?? fromFile[k];
 }
 
+// src/pool.ts
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import {
+  closeSync,
+  existsSync as existsSync3,
+  mkdirSync,
+  openSync,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync3,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname, join as join3 } from "node:path";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+var POOL_PREFIX = "aerie-pool-";
+var DEFAULT_COMMAND = [
+  "claude",
+  "--session-id",
+  "{session}",
+  // unattended: a permission prompt would stall it (the session's own rules still apply)
+  "--permission-mode",
+  "bypassPermissions",
+  "Run `peers serve {lane}`, then wait: tasks on lane {lane} come to you as prompts. Work each one to done."
+];
+function parseLanes(v, key = "pool_lanes") {
+  const out = {};
+  for (const part of v.split(",").map((x) => x.trim()).filter(Boolean)) {
+    const [lane, n] = part.split("=");
+    const k = Number(n);
+    if (!lane || !Number.isInteger(k) || k < 0) throw new Error(`${key}: "${part}" is not name=N`);
+    out[lane] = k;
+  }
+  return out;
+}
+var holds = (holder, session) => holder.endsWith(`-${session.slice(0, 4)}`);
+async function reconcile(o) {
+  const now = (o.now ?? Date.now)();
+  const out = [];
+  const live = new Set(await o.mux.list());
+  const held = await o.coord.held();
+  const queue = await o.coord.queueList();
+  const leasesOf = (s) => held.flatMap(
+    (h) => h.holders.filter((l) => holds(l.holder, s.session)).map((l) => ({ id: h.id, holder: l.holder }))
+  );
+  const fill = (s, lane) => o.command.map((a) => a.replaceAll("{session}", s).replaceAll("{lane}", lane));
+  const startSlot = async (lane, name, act, why) => {
+    const session = randomUUID();
+    await o.mux.start(name, fill(session, lane), { cwd: o.cwd });
+    o.state.slots.push({ name, lane, session, started: now, busyAt: now });
+    out.push({ act, name, lane, why });
+  };
+  for (const s of [...o.state.slots]) {
+    if (live.has(s.name)) continue;
+    for (const l of leasesOf(s)) await o.coord.release(l.id, l.holder, { queue: true });
+    o.state.slots = o.state.slots.filter((x) => x !== s);
+    if ((o.lanes[s.lane] ?? 0) > 0)
+      await startSlot(s.lane, s.name, "restart", "its tmux session is gone");
+  }
+  for (const s of o.state.slots) {
+    const st = o.sessionState(s.session);
+    if (leasesOf(s).length || st?.status === "busy" || st?.status === "shell") s.busyAt = now;
+    if (st?.waitingFor) out.push({ act: "waits", name: s.name, lane: s.lane, why: st.waitingFor });
+  }
+  for (const [lane, n] of Object.entries(o.lanes)) {
+    const mine = o.state.slots.filter((s) => s.lane === lane);
+    const queued = queue.filter((q) => q.lane === lane && !q.pin).length;
+    const busy = mine.filter((s) => s.busyAt === now).length;
+    const target = Math.min(n, busy + queued);
+    for (let i = 0; mine.length + i < target; i++) {
+      const name = `${POOL_PREFIX}${lane.replace(/[^a-z0-9]+/gi, "-")}-${randomUUID().slice(0, 4)}`;
+      await startSlot(lane, name, "start", `${queued} queued on ${lane}`);
+    }
+    let extra = mine.length - target;
+    for (const s of mine.sort((a, b) => a.busyAt - b.busyAt)) {
+      if (extra <= 0) break;
+      if (s.busyAt === now || now - s.busyAt < o.idleMs) continue;
+      await o.mux.stop(s.name);
+      o.state.slots = o.state.slots.filter((x) => x !== s);
+      out.push({
+        act: "stop",
+        name: s.name,
+        lane,
+        why: `idle ${Math.round((now - s.busyAt) / 6e4)} min, nothing queued`
+      });
+      extra--;
+    }
+  }
+  return out;
+}
+function tmuxMux(bin = "tmux") {
+  return {
+    async list() {
+      try {
+        const { stdout } = await run(bin, ["list-sessions", "-F", "#{session_name}"]);
+        return stdout.split("\n").filter((n) => n.startsWith(POOL_PREFIX));
+      } catch (e) {
+        const err = String(e.stderr ?? "");
+        if (/no server running|error connecting to/.test(err)) return [];
+        throw e;
+      }
+    },
+    async start(name, argv, o) {
+      await run(bin, ["new-session", "-d", "-s", name, "-c", o.cwd, "--", ...argv]);
+    },
+    async stop(name) {
+      await run(bin, ["kill-session", "-t", name]).catch(() => {
+      });
+    }
+  };
+}
+function claudeSessionState(dir = join3(homedir2(), ".claude", "sessions")) {
+  return (session) => {
+    for (const f of existsSync3(dir) ? readdirSync2(dir) : []) {
+      if (!f.endsWith(".json")) continue;
+      try {
+        const d = JSON.parse(readFileSync3(join3(dir, f), "utf8"));
+        if (d.sessionId === session) return d;
+      } catch {
+      }
+    }
+    return null;
+  };
+}
+var poolDir = () => join3(homedir2(), ".local", "state", "aerie");
+function loadPool(file2 = join3(poolDir(), "pool.json")) {
+  try {
+    return JSON.parse(readFileSync3(file2, "utf8"));
+  } catch {
+    return { slots: [] };
+  }
+}
+function savePool(s, file2 = join3(poolDir(), "pool.json")) {
+  mkdirSync(dirname(file2), { recursive: true });
+  writeFileSync(file2, `${JSON.stringify(s, null, 2)}
+`);
+}
+function lockPool(file2 = join3(poolDir(), "pool.lock")) {
+  mkdirSync(dirname(file2), { recursive: true });
+  for (let i = 0; i < 2; i++) {
+    try {
+      const fd = openSync(file2, "wx");
+      writeFileSync(fd, String(process.pid));
+      closeSync(fd);
+      return () => unlinkSync(file2);
+    } catch {
+      const pid = Number(readFileSync3(file2, "utf8"));
+      if (pid && alive(pid)) throw new Error(`aerie pool: already running (pid ${pid})`);
+      unlinkSync(file2);
+    }
+  }
+  throw new Error("aerie pool: cannot take the lock");
+}
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/run/spawn.ts
 init_db2();
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 var STDERR_KEEP = 64e3;
+var CLEAN_ENV = ["PATH", "USER", "LANG", "LC_ALL", "TMPDIR", "SHELL", "TERM"];
+function cleanEnv(from = process.env) {
+  const out = {};
+  for (const k of CLEAN_ENV) if (from[k] !== void 0) out[k] = from[k];
+  return out;
+}
 function runLines(bin, args, o) {
   return new Promise((resolve, reject) => {
     if (o.signal.aborted) {
@@ -38420,7 +38664,7 @@ function runLines(bin, args, o) {
     }
     const child = spawn(bin, args, {
       cwd: o.cwd,
-      env: { ...process.env, ...o.env },
+      env: o.inherit === false ? { ...cleanEnv(), ...o.env } : { ...process.env, ...o.env },
       detached: true,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -38533,6 +38777,7 @@ function claudeEvent(l) {
 function claudeRunner(o = {}) {
   return {
     name: "claude",
+    needs: ["ANTHROPIC_API_KEY"],
     async run(t, ctx) {
       let last = null;
       let session;
@@ -38583,6 +38828,7 @@ function lastText(v) {
 function codexRunner(o = {}) {
   return {
     name: "codex",
+    needs: ["OPENAI_API_KEY", "CODEX_API_KEY"],
     async run(t, ctx) {
       let summary = null;
       const r = await runLines(
@@ -38611,6 +38857,7 @@ function codexRunner(o = {}) {
 function grokRunner(o = {}) {
   return {
     name: "grok",
+    needs: ["XAI_API_KEY"],
     async run(t, ctx) {
       const out = [];
       const r = await runLines(
@@ -38638,6 +38885,7 @@ var DO_LINE = /^(done|needs-human|failed|planned) via (\S+)(?: ([^:]+))?: (.*)$/
 function autobrowseRunner(o = {}) {
   return {
     name: "autobrowse-do",
+    needs: ["AUTOBROWSE_OWNER"],
     async run(t, ctx) {
       const input2 = t.extra.input ?? {};
       const out = [];
@@ -38691,7 +38939,23 @@ function apiRunner(o) {
           summary: "no model for the api runner",
           question: `No model for ${t.id} on the api runner: set AERIE_API_MODEL, or a route rule with a model?`
         };
-      const m = modelFromSpec(spec, { ...process.env, ...o.env, ...ctx.env });
+      const tenant = ctx.inherit === false;
+      if (tenant && /^(claude-code|command)(:|$)/.test(spec))
+        return {
+          outcome: "needs-input",
+          summary: `model ${spec} runs on the host's login`,
+          question: `${t.id}: a tenant run cannot use ${spec}. Which model, on the tenant's own key?`
+        };
+      let m;
+      try {
+        m = modelFromSpec(spec, tenant ? ctx.env : { ...process.env, ...o.env, ...ctx.env });
+      } catch (e) {
+        return {
+          outcome: "needs-input",
+          summary: e.message,
+          question: `${t.id}: ${e.message}. Add the key, then answer.`
+        };
+      }
       await ctx.emit({ kind: "init", text: m.id, data: { spec, model: m.id } });
       try {
         const { value, usage } = await withDeadline(
@@ -38724,7 +38988,7 @@ You have no tools. Answer as JSON: outcome (done, needs-input or failed), summar
   };
 }
 function spawnOf(ctx) {
-  return { cwd: ctx.cwd, env: ctx.env, signal: ctx.signal };
+  return { cwd: ctx.cwd, env: ctx.env, inherit: ctx.inherit, signal: ctx.signal };
 }
 function headlessRunners(get2) {
   const opt = (name) => {
@@ -38751,9 +39015,22 @@ function headlessRunners(get2) {
 // src/run/worker.ts
 import { mkdtemp } from "node:fs/promises";
 import { hostname as hostname3, tmpdir } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 var MAX_FAILS = 3;
+async function failsSince(store, id, since) {
+  const [failed, starts, results] = await Promise.all([
+    store.countEvents(id, "run.result", { outcome: "failed" }, since),
+    store.countEvents(id, "run.start", void 0, since),
+    store.countEvents(id, "run.result", void 0, since)
+  ]);
+  return { failed, died: starts - results };
+}
 var LEASE_MS = 12e4;
+function missingCredentials(runner, tenant) {
+  const needs = runner.needs ?? [];
+  if (!needs.length || needs.some((k) => tenant.keys[k])) return [];
+  return needs;
+}
 var holderOf = (r) => `${hostname3()}/aerie-${r}-${process.pid}`;
 async function workOnce(o) {
   const { store, coord, runner } = o;
@@ -38762,7 +39039,11 @@ async function workOnce(o) {
   const leaseMs = o.leaseMs ?? LEASE_MS;
   const by = `runner:${runner.name}`;
   const lane = runLane(runner.name);
-  const took = await coord.queueTake({ lanes: [], pin: lane }, holder, leaseMs);
+  const took = await coord.queueTake(
+    { lanes: [], pin: lane, ...o.cap === void 0 ? {} : { cap: o.cap } },
+    holder,
+    leaseMs
+  );
   if (!took) return null;
   const { id, gen } = took;
   const stop = new AbortController();
@@ -38790,7 +39071,7 @@ async function workOnce(o) {
     },
     Math.max(1, Math.floor(leaseMs / 3))
   );
-  const write = async (kind, body, why) => {
+  const write2 = async (kind, body, why) => {
     if (await fenced()) await store.log(id, by, kind, body, why);
   };
   let res;
@@ -38798,8 +39079,8 @@ async function workOnce(o) {
     const t = await store.get(id);
     const routed = await store.lastEvent(id, "routed");
     const model = routed?.body?.model ?? null;
-    const cwd = o.cwdOf ? await o.cwdOf(id) : await mkdtemp(join3(tmpdir(), `aerie-run-${id}-`));
-    await write(
+    const cwd = o.cwdOf ? await o.cwdOf(id) : await mkdtemp(join4(tmpdir(), `aerie-run-${id}-`));
+    await write2(
       "run.start",
       { runner: runner.name, model, holder, gen, cwd },
       routed?.why ?? void 0
@@ -38808,16 +39089,31 @@ async function workOnce(o) {
       const opt = d2.options.find((x) => x.key === d2.answer);
       return `${d2.question} \u2192 ${opt ? opt.text : d2.answer} (${d2.answeredBy}${d2.why ? `: ${d2.why}` : ""})`;
     });
+    const missing = o.tenant ? missingCredentials(runner, o.tenant) : [];
+    const before = await failsSince(store, id, routed?.seq ?? 0);
+    const died = before.died - 1;
     if (!t) res = { outcome: "failed", summary: `task ${id} is gone` };
+    else if (before.failed + died >= MAX_FAILS)
+      res = {
+        outcome: "failed",
+        summary: `the worker died ${died} times on this task, no result written`
+      };
+    else if (missing.length && o.tenant)
+      res = {
+        outcome: "needs-input",
+        summary: `no ${runner.name} credential for tenant ${o.tenant.name}`,
+        question: `Tenant ${o.tenant.name} has no ${missing.join(" or ")} for ${runner.name}. Add it to the tenant's credentials, then answer.`
+      };
     else
       try {
         res = await runner.run(t, {
           model,
           answers,
           cwd,
-          env: { ...o.env, AERIE_TASK: id, AERIE_BY: by },
+          env: o.tenant ? { ...o.env, ...o.tenant.keys, HOME: o.tenant.home, AERIE_TASK: id, AERIE_BY: by } : { ...o.env, AERIE_TASK: id, AERIE_BY: by },
+          inherit: !o.tenant,
           signal: stop.signal,
-          emit: (e) => write(`run.${e.kind}`, { text: e.text, data: e.data })
+          emit: (e) => write2(`run.${e.kind}`, { text: e.text, data: e.data })
         });
       } catch (e) {
         res = { outcome: "failed", summary: e.message, data: { error: String(e) } };
@@ -38827,11 +39123,14 @@ async function workOnce(o) {
     o.signal?.removeEventListener("abort", onOuter);
   }
   if (lost || !await fenced()) return { id, outcome: "lost" };
-  if (o.signal?.aborted) return { id, outcome: "lost" };
+  if (o.signal?.aborted) {
+    await write2("run.result", { outcome: "stopped", said: res.outcome, summary: "worker stopped" });
+    return { id, outcome: "lost" };
+  }
   const open3 = (await store.decisions({ open: true })).find((d2) => d2.blocks.includes(id));
   const outcome = open3 ? "needs-input" : res.outcome;
   const { summary } = res;
-  await write(
+  await write2(
     "run.result",
     {
       outcome,
@@ -38851,8 +39150,8 @@ async function workOnce(o) {
     return { id, outcome, summary };
   }
   if (outcome === "failed") {
-    const since = (await store.lastEvent(id, "routed"))?.seq ?? 0;
-    const fails = await store.countEvents(id, "run.result", { outcome: "failed" }, since);
+    const n = await failsSince(store, id, (await store.lastEvent(id, "routed"))?.seq ?? 0);
+    const fails = n.failed + n.died;
     await coord.release(id, holder);
     if (!coord.ownsStatus) await store.edit(id, { status: "To Do" }, by);
     if (fails < MAX_FAILS) {
@@ -38956,7 +39255,7 @@ function registerRunCommands(program3, ctx) {
     "route a task: the first matching rule, else the router model; then queue it on its lane"
   ).option("--dry-run", "show the route, write nothing").option("--json", "JSON out").action((id, o) => {
     if (!id) return void rt.help();
-    return board(async (a, c) => {
+    return board(async (a, c, atomic2) => {
       const pick2 = await pickerOf(a);
       if (o.dryRun) {
         const t = await a.get(id);
@@ -38967,7 +39266,7 @@ function registerRunCommands(program3, ctx) {
 `
         );
       }
-      const r = await route(a, c, id, ctx.by, pick2);
+      const r = await route(a, c, id, ctx.by, pick2, atomic2);
       print2(
         o.json ? r : `${id.toUpperCase()} \u2192 ${r.runner}${r.model ? ` (${r.model})` : ""} on ${r.lane}: ${r.why}
 `
@@ -39018,7 +39317,10 @@ function registerRunCommands(program3, ctx) {
   program3.command("work").requiredOption(
     "--runner <name>",
     "a headless runner: claude | codex | grok | api | autobrowse-do"
-  ).option("--once", "one task at most, then exit").option("--lease <ms>", "lease length", String(LEASE_MS)).option("--idle <ms>", "wait between empty polls", "15000").option("--json", "one JSON line per task").description("take tasks from run:<runner>, run each, write the result").action(
+  ).option("--once", "one task at most, then exit").option("--lease <ms>", "lease length", String(LEASE_MS)).option("--idle <ms>", "wait between empty polls", "15000").option(
+    "--cap <n>",
+    "most live runs on this lane, all hosts; default setting run_cap (runner=N,...)"
+  ).option("--json", "one JSON line per task").description("take tasks from run:<runner>, run each, write the result").action(
     (o) => board(async (a, c) => {
       const name = runnerOf(o.runner);
       if (ctx.local && name !== "api")
@@ -39027,6 +39329,12 @@ function registerRunCommands(program3, ctx) {
         );
       const runner = headlessRunners(aerieEnv()).get(name);
       if (!runner) throw new Error(`${name} runs in a live session, not a worker`);
+      const caps = parseLanes(await a.getSetting("run_cap") ?? "", "run_cap");
+      const cap2 = o.cap === void 0 ? caps[name] : Number(o.cap);
+      if (cap2 !== void 0 && !(Number.isInteger(cap2) && cap2 > 0))
+        throw new Error(
+          `${o.cap === void 0 ? `run_cap ${name}` : "--cap"}: ${cap2} is not a whole number above 0`
+        );
       const stop = new AbortController();
       const quit = () => stop.abort();
       process.once("SIGINT", quit);
@@ -39041,20 +39349,105 @@ function registerRunCommands(program3, ctx) {
           idleMs: Number(o.idle),
           once: !!o.once,
           signal: stop.signal,
+          ...cap2 === void 0 ? {} : { cap: cap2 },
           onOutcome: (w) => print2(
             o.json ? `${JSON.stringify(w)}
 ` : `${w.id} ${w.outcome}${"summary" in w ? `: ${w.summary.split("\n")[0]}` : ""}
 `
           )
         });
-        if (!out.length && o.once) print2(o.json ? "null\n" : `run:${name} is empty
+        if (!out.length && o.once)
+          print2(o.json ? "null\n" : `run:${name}: nothing taken (empty, or at its cap)
+`);
+      } finally {
+        process.off("SIGINT", quit);
+        process.off("SIGTERM", quit);
+      }
+    })
+  );
+  const pool = program3.command("pool").description("session workers on this host (tmux): N per session lane, setting pool_lanes");
+  const poolOf = async (a) => {
+    const lanes = parseLanes(await a.getSetting("pool_lanes") ?? "");
+    const cmd = await a.getSetting("pool_command");
+    return {
+      lanes,
+      command: cmd ? JSON.parse(cmd) : DEFAULT_COMMAND,
+      idleMs: Number(await a.getSetting("pool_idle_min") || 30) * 6e4
+    };
+  };
+  const pass = async (a, c, mux, o) => {
+    const p = await poolOf(a);
+    const state = loadPool();
+    const acts = await reconcile({
+      mux,
+      coord: c,
+      ...p,
+      cwd: o.cwd ?? process.cwd(),
+      state,
+      sessionState: claudeSessionState()
+    });
+    savePool(state);
+    for (const x of acts)
+      print2(o.json ? `${JSON.stringify(x)}
+` : `${x.act} ${x.name} (${x.lane}): ${x.why}
 `);
+    return acts;
+  };
+  pool.command("once").option("--cwd <dir>", "where sessions start", process.cwd()).option("--json", "one JSON line per action").description("one reconcile pass: start, restart, stop").action(
+    (o) => board(async (a, c) => {
+      const unlock = lockPool();
+      try {
+        await pass(a, c, tmuxMux(), o);
+      } finally {
+        unlock();
+      }
+    })
+  );
+  pool.command("run").option("--cwd <dir>", "where sessions start", process.cwd()).option("--every <s>", "seconds between passes", "30").option("--json", "one JSON line per action").description("reconcile until stopped (launchd keeps it up); one per host").action(
+    (o) => board(async (a, c) => {
+      const unlock = lockPool();
+      const stop = new AbortController();
+      const quit = () => stop.abort();
+      process.once("SIGINT", quit);
+      process.once("SIGTERM", quit);
+      try {
+        while (!stop.signal.aborted) {
+          await pass(a, c, tmuxMux(), o).catch((e) => print2(`pool: ${e.message}
+`));
+          await new Promise((r) => {
+            const t = setTimeout(r, Number(o.every) * 1e3);
+            stop.signal.addEventListener(
+              "abort",
+              () => {
+                clearTimeout(t);
+                r();
+              },
+              { once: true }
+            );
+          });
+        }
       } finally {
+        unlock();
         process.off("SIGINT", quit);
         process.off("SIGTERM", quit);
       }
     })
   );
+  pool.command("status").option("--json", "JSON out").description("the pool's sessions on this host").action(async (o) => {
+    const s = loadPool();
+    const live = new Set(await tmuxMux().list());
+    const st = claudeSessionState();
+    const rows3 = s.slots.map((x) => ({
+      ...x,
+      alive: live.has(x.name),
+      status: st(x.session)?.status ?? null,
+      waitingFor: st(x.session)?.waitingFor ?? null
+    }));
+    print2(
+      o.json ? rows3 : rows3.length ? `${rows3.map((r) => `${r.name}  ${r.lane}  ${r.alive ? r.waitingFor ? `waits: ${r.waitingFor}` : r.status ?? "starting" : "gone"}`).join("\n")}
+` : "No pool sessions.\n"
+    );
+  });
   program3.command("events").description("the event log across tasks").command("search").argument("<words>", 'web-search words: "a phrase", -not, or').option("--task <id>", "one task").option("--kind <kind>", "one kind, e.g. run.tool or routed").option("--limit <n>", "at most n", "50").option("--json", "JSON out").action(
     (words, o) => ctx.withStore(async (a) => {
       const rs = await a.searchEvents(words, {
@@ -39082,14 +39475,14 @@ init_core();
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import {
-  existsSync as existsSync3,
-  mkdirSync,
-  readFileSync as readFileSync3,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync4,
   renameSync,
-  unlinkSync,
-  writeFileSync
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
 } from "node:fs";
-import { basename, dirname, join as join4 } from "node:path";
+import { basename, dirname as dirname2, join as join5 } from "node:path";
 init_core();
 init_store();
 var sha = (s) => createHash("sha256").update(s).digest("hex");
@@ -39115,8 +39508,8 @@ async function mirror(a, root, o = {}) {
   for (const t of tasks) {
     const was = state.get(t.id);
     const found = disk.get(t.id);
-    const cur = was && existsSync3(join4(root, was.path)) ? was.path : found?.path ?? was?.path;
-    const curText = cur && existsSync3(join4(root, cur)) ? readFileSync3(join4(root, cur), "utf8") : void 0;
+    const cur = was && existsSync4(join5(root, was.path)) ? was.path : found?.path ?? was?.path;
+    const curText = cur && existsSync4(join5(root, cur)) ? readFileSync4(join5(root, cur), "utf8") : void 0;
     if (!o.adopt) {
       const fileMoved = was !== void 0 && curText !== void 0 && (sha(curText) !== was.hash || cur !== was.path);
       if (fileMoved && was && cur && t.version === was.version) {
@@ -39154,11 +39547,11 @@ async function mirror(a, root, o = {}) {
     }
     const text3 = renderTask(strip(t));
     if (!o.dryRun) {
-      mkdirSync(dirname(join4(root, target)), { recursive: true });
-      const tmp = join4(root, `${target}.aerie-tmp`);
-      writeFileSync(tmp, text3);
-      renameSync(tmp, join4(root, target));
-      if (cur && cur !== target && existsSync3(join4(root, cur))) unlinkSync(join4(root, cur));
+      mkdirSync2(dirname2(join5(root, target)), { recursive: true });
+      const tmp = join5(root, `${target}.aerie-tmp`);
+      writeFileSync2(tmp, text3);
+      renameSync(tmp, join5(root, target));
+      if (cur && cur !== target && existsSync4(join5(root, cur))) unlinkSync2(join5(root, cur));
       await a.setMirrorFile(t.id, target, sha(text3), t.version);
     }
     if (cur && cur !== target) {
@@ -39175,7 +39568,7 @@ async function mirror(a, root, o = {}) {
   return r;
 }
 function readFile2(path2, text3) {
-  const place = dirname(path2);
+  const place = dirname2(path2);
   if (!ALL.includes(place)) return null;
   try {
     return { task: parseTask(text3), place };
@@ -39616,7 +40009,15 @@ function registerCommands(program3, ctx) {
     })
   );
   task2.command("log").argument("<id>").description("every write to a task: who, when, why").action((id) => ctx.withStore(async (a) => void print3(await a.events(id))));
-  const SETTINGS = ["router_model", "intake_model", "intake_lane"];
+  const SETTINGS = [
+    "router_model",
+    "intake_model",
+    "intake_lane",
+    "pool_lanes",
+    "pool_command",
+    "pool_idle_min",
+    "run_cap"
+  ];
   const config2 = program3.command("config").description(`board settings: statuses, task_prefix, ${SETTINGS.join(", ")}`);
   config2.command("get").argument("<key>").action(
     (key) => key === "statuses" ? print3(`${STATUSES.join(", ")}
@@ -39739,10 +40140,10 @@ ${ms2.map((m) => `  ${m.id}: ${m.title} (${m.done}/${m.total} done)`).join("\n")
   program3.command("decide").argument("<id>", "decision id").argument("<answer>", "an option key, or your own words").description(
     "answer a decision; each blocked task goes back to To Do with the answer in its notes"
   ).option("--why <text>", "why, kept with the answer and in the tasks' notes").option("--json", "JSON out").action(
-    (id, answer, o) => withBoardOrStore(async (a, c) => {
+    (id, answer, o) => withBoardOrStore(async (a, c, atomic2) => {
       const d = await a.decide(Number.parseInt(id, 10), answer, ctx.by, o.why);
       const spec = c && await a.getSetting("router_model");
-      const moved = c ? await afterDecision(a, c, d, ctx.by, spec ? modelPicker(spec) : void 0) : [];
+      const moved = c ? await afterDecision(a, c, d, ctx.by, spec ? modelPicker(spec) : void 0, atomic2) : [];
       for (const b of d.blocks) await after(a, b);
       if (o.json) return void print3(`${JSON.stringify({ ...d, requeued: moved })}
 `);
@@ -39820,6 +40221,9 @@ ${ms2.map((m) => `  ${m.id}: ${m.title} (${m.done}/${m.total} done)`).join("\n")
   registerIntakeCommands(program3, ctx);
 }
 
+// src/bin.ts
+init_db2();
+
 // src/migrations.ts
 init_drizzle_orm();
 import { fileURLToPath } from "node:url";
@@ -39923,12 +40327,12 @@ async function open2(migrateNow) {
   }
   const { PGlite: PGlite2 } = await import("@electric-sql/pglite");
   const { drizzle: drizzle3 } = await Promise.resolve().then(() => (init_pglite(), pglite_exports));
-  const pg = new PGlite2(cfg.dir ?? join6(homedir3(), ".aerie"));
+  const pg = new PGlite2(cfg.dir ?? join7(homedir4(), ".aerie"));
   const db = drizzle3(pg);
   await migrateAerie(db);
   return { db, close: () => pg.close() };
 }
-var pkg = JSON.parse(readFileSync5(new URL("../package.json", import.meta.url), "utf8"));
+var pkg = JSON.parse(readFileSync6(new URL("../package.json", import.meta.url), "utf8"));
 var program2 = new Command("aerie").description("One task system for every agent: areas, roles, a board; Backlog.md's flags").showHelpAfterError();
 registerCommands(program2, {
   by: cfg.by ?? `@${userInfo().username}`,
@@ -39950,14 +40354,17 @@ registerCommands(program2, {
   async withBoard(fn) {
     const { db, close } = await open2(false);
     const { pgCoord: pgCoord2 } = await Promise.resolve().then(() => (init_postgres(), postgres_exports));
-    try {
-      const store = aerieStore({ db, ...cfg.prefix ? { prefix: cfg.prefix } : {} });
-      const coord = pgCoord2({
-        db,
+    const pair = (q) => [
+      aerieStore({ db: q, ...cfg.prefix ? { prefix: cfg.prefix } : {} }),
+      pgCoord2({
+        db: q,
         ns: cfg.coordNs ?? "main",
         status: { doing: "In Progress", done: "Done", ready: "To Do", queued: "To Do" }
-      });
-      return await fn(store, coord);
+      })
+    ];
+    try {
+      const [store, coord] = pair(db);
+      return await fn(store, coord, (f) => atomic(db, (tx) => f(...pair(tx))));
     } finally {
       await close();
     }