@kubitnodes/stellaris 0.3.18 → 0.3.20

package/dist/cli/index.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 // apps/cli/dist/index.js
-import { readFile as readFile6 } from "node:fs/promises";
+import { readFile as readFile5 } from "node:fs/promises";
 import path7 from "node:path";
 import { Command } from "commander";
 
 // packages/board-core/dist/board.js
-import { mkdir as mkdir4, readdir as readdir3, readFile as readFile5, rename as rename3, stat as stat2 } from "node:fs/promises";
+import { chmod as chmod2, cp, mkdir as mkdir4, readdir as readdir3, readFile as readFile4, rename as rename3, rm as rm2, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
 import path6 from "node:path";
 import { decodeTime, monotonicFactory } from "ulid";
 import { z as z13 } from "zod";
@@ -422,6 +422,13 @@ var MessageFrontmatterSchema = z4.object({
   ts: IsoDateTimeSchema,
   mentions: z4.array(NameSchema)
 });
+var MessageRefSchema = MessageFrontmatterSchema.pick({
+  id: true,
+  author: true,
+  channel: true,
+  thread: true,
+  ts: true
+});
 var TaskStatusSchema = z4.enum(["open", "claimed", "done", "abandoned"]);
 var ThreadStateSchema = z4.enum(["open", "closed"]);
 var ThreadSubjectSchema = z4.object({
@@ -622,7 +629,7 @@ var ArchiveProposalSchema = z4.object({
 var SkillProposalSchema = z4.object({
   name: NameSchema,
   summary: z4.string().min(1).max(200),
-  body: z4.string().min(1)
+  body: z4.string().min(1).optional()
 });
 var ProposalCharterSchemas = {
   role: RoleCharterSchema,
@@ -749,6 +756,7 @@ var HomeFileDiffSchema = HomeFileChangeSchema.pick({ path: true, status: true })
 var KnowledgeSchema = z4.object({
   topic: NameSchema,
   project: NameSchema.nullable(),
+  revision: z4.number().int().min(0),
   updatedBy: NameSchema,
   updatedAt: IsoDateTimeSchema
 });
@@ -771,6 +779,24 @@ var ProposalOriginSchema = z4.object({
   thread: UlidSchema.optional(),
   channel: NameSchema.optional()
 });
+var SKILL_FILES_LIMIT = 100;
+var SKILL_BYTES_LIMIT = 10 * 1024 * 1024;
+var SkillFileSchema = z4.object({
+  path: z4.string().min(1),
+  size: z4.number().int().nonnegative(),
+  executable: z4.boolean()
+});
+var SkillFilesSchema = z4.object({
+  /** The commit of the proposer's home the files came from. */
+  commit: CommitIdSchema,
+  takenAt: IsoDateTimeSchema,
+  files: z4.array(SkillFileSchema)
+});
+var SkillFileContentSchema = SkillFileSchema.extend({
+  text: z4.string().nullable(),
+  /** The text was cut at its size limit. */
+  truncated: z4.boolean()
+});
 var ProposalFrontmatterSchema = z4.object({
   id: UlidSchema,
   kind: ProposalKindSchema,
@@ -779,6 +805,8 @@ var ProposalFrontmatterSchema = z4.object({
   createdAt: IsoDateTimeSchema,
   /** Absent for a proposal filed outside a turn, or before proposals recorded it. */
   filedFrom: ProposalOriginSchema.optional(),
+  /** A skill proposal's folder, once taken; absent for one proposed as text alone. */
+  skillFiles: SkillFilesSchema.optional(),
   decidedBy: NameSchema.optional(),
   decidedAt: IsoDateTimeSchema.optional(),
   reason: z4.string().optional(),
@@ -881,7 +909,9 @@ var VerbInputs = {
     /** A project you belong to, or null for society knowledge, which the steward and the user curate. */
     project: NameSchema.nullable().default(null),
     topic: NameSchema,
-    body: z5.string().min(1)
+    body: z5.string().min(1),
+    /** The `revision` in the frontmatter of the topic you read, 0 when it names none or for a new topic. */
+    revision: z5.number().int().min(0)
   }),
   remove_knowledge: z5.object({
     /** As for write_knowledge: a project you belong to, or null for society knowledge. */
@@ -982,6 +1012,7 @@ var BOARD_EVENT_TYPES = [
   "proposal.created",
   "proposal.decided",
   "proposal.provisioned",
+  "proposal.files_taken",
   "channel.added",
   "channel.archived",
   "role.added",
@@ -1388,6 +1419,9 @@ var RunnerAnswerSchema = z7.discriminatedUnion("ok", [
 ]);
 var WarmSessionsSchema = z7.object({ warm: z7.array(z7.string()) });
 var FileManifestSchema = z7.object({ files: z7.record(z7.string(), z7.string()) });
+function fileVersion(sha, executable) {
+  return executable ? `${sha}+x` : sha;
+}
 var FileReadSchema = z7.object({ paths: z7.array(z7.string()) });
 var FileContentsSchema = z7.object({ files: z7.record(z7.string(), z7.string()) });
 function isSafeRelativePath(file) {
@@ -1706,7 +1740,7 @@ var RunnerConfigSchema = z11.object({
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.3.18";
+var STELLARIS_VERSION = "0.3.20";
 
 // packages/board-core/dist/errors.js
 var BoardError = class extends Error {
@@ -1719,7 +1753,7 @@ var BoardError = class extends Error {
 };
 
 // packages/board-core/dist/events.js
-import { appendFile, readFile as readFile2 } from "node:fs/promises";
+import { appendFile, open, stat } from "node:fs/promises";
 import path2 from "node:path";
 
 // packages/board-core/dist/fs.js
@@ -1760,7 +1794,9 @@ async function readMarkdown(file, schema) {
   return { data: schema.parse(parsed.data), body: parsed.content.replace(/^\n/, "") };
 }
 async function readLooseMarkdown(file) {
-  const raw = await readFile(file, "utf8");
+  return parseLooseMarkdown(await readFile(file, "utf8"));
+}
+function parseLooseMarkdown(raw) {
   try {
     const parsed = parseMatter(raw);
     return { data: parsed.data, body: parsed.content.replace(/^\n/, ""), error: null };
@@ -1802,10 +1838,19 @@ async function listDirs(dir) {
 
 // packages/board-core/dist/events.js
 var LEADING_ID = /^\{"id":"([0-9A-HJKMNP-TV-Z]{26})"/;
+var ID_PREFIX_BYTES = 64;
+var NEWLINE = 10;
 var EventLog = class {
   file;
   newId;
   now;
+  lines = [];
+  /** Bytes the index covers: always the end of a complete line. */
+  indexed = 0;
+  /** The indexed file, to tell a replaced log from a grown one. */
+  inode = null;
+  scanning = Promise.resolve();
+  listeners = /* @__PURE__ */ new Set();
   constructor(file, newId, now) {
     this.file = file;
     this.newId = newId;
@@ -1822,48 +1867,97 @@ var EventLog = class {
     await ensureDir(path2.dirname(this.file));
     await appendFile(this.file, `${JSON.stringify(event)}
 `, "utf8");
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
     return event;
   }
+  /**
+   * Calls `listener` after each event this process appends, until the returned function is
+   * called. Another process's appends, such as the admin CLI's, are seen only by the next read.
+   */
+  onAppend(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
   /** Events with an id greater than `since`, oldest first. `null` reads from the beginning. */
   async readSince(since, limit = 1e3) {
-    if (!await exists(this.file)) {
-      return [];
-    }
-    const raw = await readFile2(this.file, "utf8");
-    const events = [];
-    for (const line of raw.split("\n")) {
-      if (line.trim().length === 0) {
-        continue;
-      }
-      const leading = LEADING_ID.exec(line)?.[1];
-      if (since !== null && leading !== void 0 && leading <= since) {
-        continue;
-      }
-      const event = BoardEventSchema.parse(JSON.parse(line));
-      if (since !== null && event.id <= since) {
+    await this.refresh();
+    const chosen = [];
+    for (const line of this.lines) {
+      if (since !== null && line.id <= since) {
         continue;
       }
-      events.push(event);
-      if (events.length >= limit) {
+      chosen.push(line);
+      if (chosen.length >= limit) {
         break;
       }
     }
-    return events;
+    const first = chosen[0];
+    const last = chosen.at(-1);
+    if (first === void 0 || last === void 0) {
+      return [];
+    }
+    const span = await this.readBytes(first.start, last.end);
+    return chosen.map((line) => BoardEventSchema.parse(JSON.parse(span.toString("utf8", line.start - first.start, line.end - first.start))));
   }
   /** The id of the newest event, or null for an empty log. */
   async lastId() {
-    if (!await exists(this.file)) {
-      return null;
+    await this.refresh();
+    return this.lines.at(-1)?.id ?? null;
+  }
+  /** Brings the index up to the file's end, one scan at a time. */
+  refresh() {
+    this.scanning = this.scanning.then(() => this.scan(), () => this.scan());
+    return this.scanning;
+  }
+  async scan() {
+    const info = await stat(this.file).catch((error) => {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    });
+    if (info === null || info.ino !== this.inode || info.size < this.indexed) {
+      this.lines = [];
+      this.indexed = 0;
+      this.inode = info?.ino ?? null;
+    }
+    if (info === null || info.size === this.indexed) {
+      return;
+    }
+    const added = await this.readBytes(this.indexed, info.size);
+    let start = 0;
+    for (let at = added.indexOf(NEWLINE); at >= 0; at = added.indexOf(NEWLINE, start)) {
+      const prefix = added.toString("utf8", start, Math.min(at, start + ID_PREFIX_BYTES));
+      if (prefix.trim().length > 0) {
+        const id = LEADING_ID.exec(prefix)?.[1] ?? BoardEventSchema.parse(JSON.parse(added.toString("utf8", start, at))).id;
+        this.lines.push({ id, start: this.indexed + start, end: this.indexed + at });
+      }
+      start = at + 1;
+    }
+    this.indexed += start;
+  }
+  async readBytes(from, to) {
+    const handle = await open(this.file, "r");
+    try {
+      const buffer = Buffer.alloc(to - from);
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, from);
+      return buffer.subarray(0, bytesRead);
+    } finally {
+      await handle.close();
     }
-    const lines = (await readFile2(this.file, "utf8")).trimEnd().split("\n");
-    const last = lines.at(-1) ?? "";
-    return last.length === 0 ? null : BoardEventSchema.parse(JSON.parse(last)).id;
   }
 };
 
 // packages/board-core/dist/files.js
 import { createHash } from "node:crypto";
-import { mkdir as mkdir2, readdir as readdir2, readFile as readFile3, rename as rename2, rm, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir2, readdir as readdir2, readFile as readFile2, rename as rename2, rm, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
 import path3 from "node:path";
 var MAX_FILE_BYTES = 8 * 1024 * 1024;
 function isMissing2(error) {
@@ -1885,9 +1979,9 @@ var FileTree = class {
       }
       try {
         const absolute = path3.join(root, ...relative.split("/"));
-        const info = await stat(absolute);
+        const info = await stat2(absolute);
         if (info.isFile() && info.size <= MAX_FILE_BYTES) {
-          files[relative] = (await readFile3(absolute)).toString("base64");
+          files[relative] = (await readFile2(absolute)).toString("base64");
         }
       } catch (error) {
         if (!isMissing2(error)) {
@@ -1943,17 +2037,18 @@ var FileTree = class {
   }
   async hash(absolute) {
     try {
-      const info = await stat(absolute);
+      const info = await stat2(absolute);
       if (info.size > MAX_FILE_BYTES) {
         return null;
       }
+      const executable = (info.mode & 73) !== 0;
       const known = this.hashes.get(absolute);
       if (known !== void 0 && known.mtimeMs === info.mtimeMs && known.size === info.size) {
-        return known.sha;
+        return fileVersion(known.sha, executable);
       }
-      const sha = createHash("sha256").update(await readFile3(absolute)).digest("hex");
+      const sha = createHash("sha256").update(await readFile2(absolute)).digest("hex");
       this.hashes.set(absolute, { mtimeMs: info.mtimeMs, size: info.size, sha });
-      return sha;
+      return fileVersion(sha, executable);
     } catch (error) {
       if (isMissing2(error)) {
         return null;
@@ -1964,7 +2059,7 @@ var FileTree = class {
 };
 
 // packages/board-core/dist/homes.js
-import { chmod, mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { chmod, mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
 import path4 from "node:path";
 import { execa } from "execa";
 var HOME_GITIGNORE = [
@@ -2108,7 +2203,7 @@ var HomeRepos = class {
       await writeFile3(ignore, IGNORE_FILE, "utf8");
       await git(["add", "--all"], home);
       await git(["commit", "--quiet", "--allow-empty", "-m", "home: created by the board"], home);
-    } else if (await readFile4(ignore, "utf8").catch(() => "") !== IGNORE_FILE) {
+    } else if (await readFile3(ignore, "utf8").catch(() => "") !== IGNORE_FILE) {
       await writeFile3(ignore, IGNORE_FILE, "utf8");
       await git(["add", ".gitignore"], home);
       await git(["commit", "--quiet", "-m", "home: the board's ignore file"], home);
@@ -2204,6 +2299,55 @@ var HomeRepos = class {
     }
     return files;
   }
+  /**
+   * The files of a folder in a home's newest commit, by path within the folder, with the commit;
+   * conflict copies and anything but a regular file are left out. Null when the home is not a
+   * repository yet.
+   */
+  async folder(home, folder) {
+    if (!await exists(path4.join(home, ".git"))) {
+      return null;
+    }
+    const commit = (await read(home, ["rev-parse", "--verify", "HEAD^{commit}"])).trim();
+    const prefix = `${folder}/`;
+    const listed = await read(home, [
+      "ls-tree",
+      "-r",
+      "-z",
+      "--long",
+      "--full-tree",
+      commit,
+      prefix
+    ]);
+    const files = [];
+    for (const entry of listed.split("\0")) {
+      const match = /^(100644|100755) blob ([0-9a-f]+) +(\d+)\t(.+)$/.exec(entry);
+      const [, mode = "", object = "", size = "0", file = ""] = match ?? [];
+      if (match === null || !file.startsWith(prefix) || !isSafeRelativePath(file) || conflictCopyOf(file) !== null) {
+        continue;
+      }
+      files.push({
+        path: file.slice(prefix.length),
+        object,
+        size: Number.parseInt(size, 10),
+        executable: mode === "100755"
+      });
+    }
+    return { commit, files };
+  }
+  /** A blob of a home's repository, as `folder` names it. */
+  async blob(home, object) {
+    const result = await execa("git", ["cat-file", "blob", object], {
+      cwd: home,
+      encoding: "buffer",
+      stripFinalNewline: false,
+      reject: false
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`git cat-file failed: ${Buffer.from(result.stderr).toString().trim()}`);
+    }
+    return Buffer.from(result.stdout);
+  }
   /** The conflict copies a merge added, against its first parent. */
   async keptCopies(home, parent, commit) {
     const added = await read(home, [
@@ -2619,6 +2763,10 @@ var BoardPaths = class {
   proposal(id) {
     return path5.join(this.proposals(), `${id}.md`);
   }
+  /** A skill proposal's folder, as the board took it from its proposer's home. */
+  proposalFiles(id) {
+    return path5.join(this.proposals(), id);
+  }
   decisions() {
     return path5.join(this.society, "decisions");
   }
@@ -2870,6 +3018,20 @@ var MENTION_PATTERN = /(^|[^\w@])@([a-z0-9][a-z0-9-]{0,31})(?![\w-])/g;
 function withoutMentions(text) {
   return text.replaceAll(MENTION_PATTERN, "$1$2");
 }
+var SKILL_TEXT_LIMIT_CHARS = 1e5;
+function skillFolderOf(proposal2) {
+  if (proposal2.kind !== "skill") {
+    return null;
+  }
+  const parsed = SkillProposalSchema.safeParse(proposal2.charter);
+  return parsed.success && parsed.data.body === void 0 ? parsed.data.name : null;
+}
+function proposedFrom(origin, where) {
+  return origin !== void 0 && origin.scope === where.scope && origin.thread === where.thread && origin.channel === where.channel;
+}
+function megabytes(bytes) {
+  return (bytes / (1024 * 1024)).toFixed(1).replace(/\.0$/, "");
+}
 var CURATING_ROLES = [USER_ROLE, "steward"];
 var SEED_INSTRUCTIONS_HEADING = "## Seed instructions";
 var OPS_WAKE_TRIGGER = "ops_event";
@@ -2960,8 +3122,8 @@ function restage(existing, edit) {
   };
 }
 function reopenStage(stage) {
-  const { completedBy: _by, completedAt: _at, ...open2 } = stage;
-  return open2;
+  const { completedBy: _by, completedAt: _at, ...open3 } = stage;
+  return open3;
 }
 function gateChanges(before, after) {
   const changes = [];
@@ -3356,7 +3518,7 @@ var Board = class _Board {
         const task2 = { ...TaskFrontmatterSchema.parse(raw.data), body: raw.body };
         if ((legacy === "open" || legacy === "closed") && !await exists(this.paths.threadFile(threads, task2.id))) {
           const ended = task2.status === "done" || task2.status === "abandoned";
-          const open2 = legacy === "open" && !ended;
+          const open3 = legacy === "open" && !ended;
           const openedBy = opened.get(task2.id);
           const closedBy = closed.get(task2.id);
           await this.writeThread(threads, {
@@ -3364,10 +3526,10 @@ var Board = class _Board {
             channel: channelRef(slug, "general"),
             title: task2.title,
             subject: { kind: "task", id: task2.id },
-            state: open2 ? "open" : "closed",
+            state: open3 ? "open" : "closed",
             openedBy: openedBy?.actor ?? task2.createdBy,
             openedAt: openedBy?.ts ?? task2.createdAt,
-            ...open2 ? {} : {
+            ...open3 ? {} : {
               closedBy: closedBy?.actor ?? SYSTEM_ACTOR.name,
               closedAt: closedBy?.ts ?? this.now().toISOString()
             },
@@ -3430,7 +3592,7 @@ var Board = class _Board {
     for (const agent2 of await this.listAgents()) {
       const file = this.paths.agentCursors(agent2.name);
       if (await exists(file)) {
-        const legacy = Legacy.safeParse(JSON.parse(await readFile5(file, "utf8")));
+        const legacy = Legacy.safeParse(JSON.parse(await readFile4(file, "utf8")));
         if (legacy.success) {
           await writeJson(file, { digest: legacy.data.inbox });
         }
@@ -3769,6 +3931,10 @@ ${charter.purpose}
   async latestEventId() {
     return this.events.lastId();
   }
+  /** Calls `listener` after each event the board appends, until the returned function is called. */
+  onEventAppended(listener) {
+    return this.events.onAppend(listener);
+  }
   /** The roster as projected: every citizen with identity, reach, availability, and profile. */
   async listMembers() {
     const members = [];
@@ -3792,22 +3958,41 @@ ${charter.purpose}
     const dir = project2 === null ? this.paths.societyKnowledge() : this.paths.projectKnowledge(project2);
     const topics = [];
     for (const file of await listFiles(dir)) {
-      const doc = await readMarkdown(path6.join(dir, file), z13.record(z13.string(), z13.unknown()));
-      const parsed = KnowledgeSchema.safeParse({
-        ...doc.data,
-        project: project2,
-        topic: file.replace(/\.md$/, "")
-      });
-      const data = parsed.success ? parsed.data : {
-        topic: file.replace(/\.md$/, ""),
-        project: project2,
-        updatedBy: SYSTEM_ACTOR.name,
-        updatedAt: (await stat2(path6.join(dir, file))).mtime.toISOString()
-      };
-      topics.push({ ...data, body: doc.body });
+      topics.push(await this.knowledgeAt(path6.join(dir, file), project2, file.replace(/\.md$/, "")));
     }
     return topics;
   }
+  knowledgeFile(project2, topic) {
+    return project2 === null ? this.paths.societyKnowledgeFile(topic) : this.paths.projectKnowledgeFile(project2, topic);
+  }
+  /**
+   * Read loosely, as a dashboard is: a topic written before revisions counts as revision 0, and an
+   * author or a time that does not parse is the board's at the file's mtime.
+   */
+  async knowledgeAt(file, project2, topic) {
+    const { data, body } = await readLooseMarkdown(file);
+    const revision = z13.number().int().min(0).safeParse(data["revision"]);
+    const updatedBy = NameSchema.safeParse(data["updatedBy"]);
+    const updatedAt = IsoDateTimeSchema.safeParse(data["updatedAt"]);
+    return {
+      topic,
+      project: project2,
+      revision: revision.success ? revision.data : 0,
+      updatedBy: updatedBy.success ? updatedBy.data : SYSTEM_ACTOR.name,
+      updatedAt: updatedAt.success ? updatedAt.data : (await stat3(file)).mtime.toISOString(),
+      body
+    };
+  }
+  /** The highest revision among a topic's removed copies, 0 when it has none. */
+  async removedRevision(project2, topic) {
+    const aside = this.paths.removedKnowledge(project2 ?? SOCIETY_SCOPE);
+    let highest = 0;
+    for (const file of (await listFiles(aside)).filter((name) => name.startsWith(`${topic}.`))) {
+      const copy = await this.knowledgeAt(path6.join(aside, file), project2, topic);
+      highest = Math.max(highest, copy.revision);
+    }
+    return highest;
+  }
   /** Skills promoted to the society: every citizen may read them. */
   async listSocietySkills() {
     return this.listSkillsIn(this.paths.societySkills(), "society");
@@ -3896,6 +4081,28 @@ ${charter.purpose}
   async readThread(id) {
     return (await this.findThread(id)).thread;
   }
+  /**
+   * Where each of the messages named is and who wrote it, for text that names them by id; an id
+   * that names no message is left out. Message files start with their ids, so only the files
+   * asked for are read.
+   */
+  async findMessages(ids) {
+    const wanted = new Set(ids);
+    const found = [];
+    for await (const dir of this.messageDirs()) {
+      for (const file of await listFiles(dir)) {
+        if (!wanted.delete(file.slice(0, 26))) {
+          continue;
+        }
+        const { data } = await readMarkdown(path6.join(dir, file), MessageFrontmatterSchema);
+        found.push(MessageRefSchema.parse(data));
+      }
+      if (wanted.size === 0) {
+        break;
+      }
+    }
+    return found;
+  }
   /**
    * What citizens have asked the user and the user has not answered, oldest first: every message
    * by someone else that mentions the user, in an open thread or a channel the society or an
@@ -4397,12 +4604,12 @@ ${DASHBOARD_LINE}
         continue;
       }
       const named = thread2 === null ? channelConversation(filedIn, message.channel) : void 0;
-      let open2 = named === void 0 ? void 0 : openChannels.get(message.channel);
-      if (named !== void 0 && open2 === void 0) {
-        open2 = await this.channelOpen(message.channel);
-        openChannels.set(message.channel, open2);
+      let open3 = named === void 0 ? void 0 : openChannels.get(message.channel);
+      if (named !== void 0 && open3 === void 0) {
+        open3 = await this.channelOpen(message.channel);
+        openChannels.set(message.channel, open3);
       }
-      const part = thread2 ?? (open2 === true ? `#${named}` : null);
+      const part = thread2 ?? (open3 === true ? `#${named}` : null);
       if (conversation !== void 0 && (filedIn !== conversation.scope || part !== conversation.part)) {
         continue;
       }
@@ -4467,7 +4674,7 @@ ${task2.body}`;
         }
       }
       for (const file of await listFiles(this.paths.projectKnowledge(project2))) {
-        const content = await readFile5(path6.join(this.paths.projectKnowledge(project2), file), "utf8");
+        const content = await readFile4(path6.join(this.paths.projectKnowledge(project2), file), "utf8");
         if (content.toLowerCase().includes(needle)) {
           hits.push({
             kind: "knowledge",
@@ -4505,7 +4712,7 @@ ${task2.body}`;
       });
     }
     for (const entry of shared) {
-      const content = await readFile5(entry.file, "utf8");
+      const content = await readFile4(entry.file, "utf8");
       if (content.toLowerCase().includes(needle)) {
         hits.push({
           kind: entry.kind,
@@ -4521,26 +4728,42 @@ ${task2.body}`;
   }
   /**
    * Writes a topic: a project's by its members, the society's by the curating roles. The note in
-   * the matching general channel carries no mention, so nobody is woken.
+   * the matching general channel carries no mention, so nobody is woken. A turn reads a topic from
+   * the copy of the projection pulled when it started, so a revision other than the current one, 0
+   * for a topic not there, means someone wrote or removed it since; the refusal carries the current
+   * text, which that copy lacks.
    */
   async writeKnowledge(actor, input) {
     const args = VerbInputs.write_knowledge.parse(input);
     await this.authorize(actor, "write_knowledge");
     return this.mutex.run(async () => {
       await this.assertMayCurate(actor, args.project);
+      const file = this.knowledgeFile(args.project, args.topic);
+      const current = await exists(file) ? await this.knowledgeAt(file, args.project, args.topic) : null;
+      const place = args.project ?? "the society";
+      if (current === null && args.revision !== 0) {
+        throw new BoardError("INVALID_STATE", `${place} has no knowledge topic ${args.topic}, so it has no revision ${args.revision}: it was removed since you read it, or never written. Write it with revision 0 to start it anew.`);
+      }
+      if (current !== null && args.revision !== current.revision) {
+        throw new BoardError("INVALID_STATE", `the knowledge topic ${args.topic} of ${place} is at revision ${current.revision}, updated by ${current.updatedBy} at ${current.updatedAt}, not ${args.revision}. Merge your changes into its current text, below, and write again with revision ${current.revision}.
+
+${current.body}`);
+      }
+      const base = current?.revision ?? await this.removedRevision(args.project, args.topic);
       const data = KnowledgeSchema.parse({
         topic: args.topic,
         project: args.project,
+        revision: base + 1,
         updatedBy: actor.name,
         updatedAt: this.now().toISOString()
       });
-      const file = args.project === null ? this.paths.societyKnowledgeFile(args.topic) : this.paths.projectKnowledgeFile(args.project, args.topic);
-      const replaced = await exists(file);
+      const replaced = current !== null;
       await writeMarkdown(file, data, args.body);
       await this.events.append("knowledge.written", actor.name, {
         topic: args.topic,
         project: args.project,
-        replaced
+        replaced,
+        revision: data.revision
       });
       const where = args.project === null ? "general" : channelRef(args.project, "general");
       await this.appendMessage(actor.name, where, `Knowledge ${replaced ? "updated" : "written"}: ${args.topic}. It is under knowledge/${args.topic}.md${args.project === null ? " of the society" : ""}.`, {
@@ -4563,7 +4786,7 @@ ${task2.body}`;
     await this.authorize(actor, "remove_knowledge");
     return this.mutex.run(async () => {
       await this.assertMayCurate(actor, args.project);
-      const file = args.project === null ? this.paths.societyKnowledgeFile(args.topic) : this.paths.projectKnowledgeFile(args.project, args.topic);
+      const file = this.knowledgeFile(args.project, args.topic);
       if (!await exists(file)) {
         throw new BoardError("NOT_FOUND", `${args.project ?? "the society"} has no knowledge topic ${args.topic}`);
       }
@@ -5614,7 +5837,7 @@ ${args.summary}`);
       throw new BoardError("VALIDATION", `invalid ${args.kind} charter: ${parsed.error.message}`);
     }
     return this.mutex.run(async () => {
-      const proposal2 = {
+      let proposal2 = {
         ...ProposalFrontmatterSchema.parse({
           id: this.newId(),
           kind: args.kind,
@@ -5633,6 +5856,14 @@ ${args.summary}`);
         body: args.rationale
       };
       await this.validateProvision(proposal2.kind, proposal2.charter);
+      const skill2 = skillFolderOf(proposal2);
+      if (skill2 !== null && proposal2.filedFrom === void 0) {
+        const taken = await this.takeSkillFolderUnlocked(proposal2, skill2);
+        if (typeof taken === "string") {
+          throw new BoardError("VALIDATION", taken);
+        }
+        proposal2 = { ...proposal2, skillFiles: taken };
+      }
       await this.writeProposal(proposal2);
       await this.events.append("proposal.created", actor.name, {
         proposalId: proposal2.id,
@@ -5970,7 +6201,7 @@ ${rationale}`}`);
       throw new BoardError("NOT_FOUND", `no transcript of turn ${turnId} for ${agent2}`);
     }
     const entries = [];
-    for (const line of (await readFile5(file, "utf8")).split("\n")) {
+    for (const line of (await readFile4(file, "utf8")).split("\n")) {
       if (line.trim() === "")
         continue;
       const parsed = TranscriptEntrySchema.safeParse(JSON.parse(line));
@@ -6449,7 +6680,7 @@ ${rationale}`}`);
         }
         const file = entry.isFile() ? conflictCopyOf(relative) : null;
         if (file !== null) {
-          const since = await this.homes.changedAt(home, relative) ?? (await stat2(path6.join(home, relative)).catch(() => null))?.mtime.toISOString();
+          const since = await this.homes.changedAt(home, relative) ?? (await stat3(path6.join(home, relative)).catch(() => null))?.mtime.toISOString();
           if (since !== void 0) {
             found.push({ path: relative, file, since });
           }
@@ -6849,7 +7080,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       }
       case "skill": {
         const skill2 = SkillProposalSchema.parse(proposal2.charter);
-        const replaced = await this.promoteSkillUnlocked(by, proposal2.proposedBy, skill2, meta);
+        const replaced = await this.promoteSkillUnlocked(by, proposal2, skill2, meta);
         return { skill: skill2.name, replaced };
       }
       case "archive": {
@@ -6863,26 +7094,180 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
         return void 0;
     }
   }
-  /** Writes a promoted skill under the society's skills, where every citizen's skills index lists it. */
-  async promoteSkillUnlocked(by, proposedBy, skill2, meta) {
+  /**
+   * Publishes a promoted skill under the society's skills, where every citizen's skills index lists
+   * it: the folder the board took from its proposer's home, or the text proposed alone. A
+   * replacement is the whole skill, so files the new version dropped go with the old one.
+   */
+  async promoteSkillUnlocked(by, proposal2, skill2, meta) {
+    const dir = this.paths.societySkill(skill2.name);
     const file = this.paths.societySkillFile(skill2.name);
     const replaced = await exists(file);
-    await ensureDir(this.paths.societySkill(skill2.name));
+    const taken = proposal2.skillFiles;
+    const staged = path6.join(this.paths.proposalFiles(proposal2.id), "SKILL.md");
+    if (skill2.body === void 0 && (taken === void 0 || !await exists(staged))) {
+      throw new BoardError("INVALID_STATE", `proposal ${proposal2.id} holds no skill files`);
+    }
+    await rm2(dir, { recursive: true, force: true });
+    if (skill2.body === void 0) {
+      await cp(this.paths.proposalFiles(proposal2.id), dir, { recursive: true });
+    } else {
+      await ensureDir(dir);
+    }
+    const body = skill2.body ?? (await readLooseMarkdown(file)).body;
     await writeMarkdown(file, {
       name: skill2.name,
       description: skill2.summary,
-      metadata: { proposedBy, promotedBy: by, promotedAt: this.now().toISOString() }
-    }, skill2.body);
+      metadata: {
+        proposedBy: proposal2.proposedBy,
+        promotedBy: by,
+        promotedAt: this.now().toISOString(),
+        ...taken === void 0 ? {} : { commit: taken.commit }
+      }
+    }, body);
     await this.events.append("skill.promoted", by, {
       name: skill2.name,
       summary: skill2.summary,
-      proposedBy,
+      proposedBy: proposal2.proposedBy,
       replaced,
+      ...taken === void 0 ? {} : { files: taken.files.length },
       ...meta
     });
     await this.appendMessage(SYSTEM_ACTOR.name, "general", `Skill ${skill2.name} ${replaced ? "updated in" : "promoted to"} the society: ${sentence(skill2.summary)}. Every citizen's skills index now lists it.`);
     return replaced;
   }
+  /**
+   * Copies a skill's folder from its proposer's home, as the home's newest commit holds it, into the
+   * proposal's folder in the projection, where its deciders read it and from where approval
+   * publishes it. Returns what was taken, or why the home could not give it.
+   */
+  async takeSkillFolderUnlocked(proposal2, name) {
+    const home = this.paths.agent(proposal2.proposedBy);
+    const folder = `skills/${name}`;
+    const where = `${folder} in ${proposal2.proposedBy}'s home`;
+    const taken = await this.homes.folder(home, folder);
+    if (taken === null || !taken.files.some((entry) => entry.path === "SKILL.md")) {
+      return `no ${folder}/SKILL.md in ${proposal2.proposedBy}'s home`;
+    }
+    if (taken.files.length > SKILL_FILES_LIMIT) {
+      return `${where} holds ${taken.files.length} files, more than the ${SKILL_FILES_LIMIT} a society skill may`;
+    }
+    const bytes = taken.files.reduce((sum, entry) => sum + entry.size, 0);
+    if (bytes > SKILL_BYTES_LIMIT) {
+      return `${where} holds ${megabytes(bytes)} MB, more than the ${megabytes(SKILL_BYTES_LIMIT)} MB a society skill may`;
+    }
+    const contents = /* @__PURE__ */ new Map();
+    for (const entry of taken.files) {
+      contents.set(entry.path, await this.homes.blob(home, entry.object));
+    }
+    const manual = parseLooseMarkdown(contents.get("SKILL.md")?.toString("utf8") ?? "");
+    if (manual.error !== null) {
+      return `the frontmatter of ${folder}/SKILL.md in ${proposal2.proposedBy}'s home does not parse (${manual.error})`;
+    }
+    const dir = this.paths.proposalFiles(proposal2.id);
+    await rm2(dir, { recursive: true, force: true });
+    for (const entry of taken.files) {
+      const target = path6.join(dir, ...entry.path.split("/"));
+      await ensureDir(path6.dirname(target));
+      await writeFile4(target, contents.get(entry.path) ?? Buffer.alloc(0));
+      await chmod2(target, entry.executable ? 493 : 420);
+    }
+    return {
+      commit: taken.commit,
+      takenAt: this.now().toISOString(),
+      files: taken.files.map((entry) => ({
+        path: entry.path,
+        size: entry.size,
+        executable: entry.executable
+      }))
+    };
+  }
+  /** Keeps what was taken of a skill proposal's folder on the proposal, and logs it. */
+  async recordSkillFiles(proposal2, taken) {
+    const next = { ...proposal2, skillFiles: taken };
+    await this.writeProposal(next);
+    await this.events.append("proposal.files_taken", SYSTEM_ACTOR.name, {
+      proposalId: proposal2.id,
+      kind: proposal2.kind,
+      proposedBy: proposal2.proposedBy,
+      commit: taken.commit,
+      files: taken.files.length
+    });
+    return next;
+  }
+  /**
+   * A skill proposal with its folder, for approval: taken now when the turn that filed it ended
+   * without it, as when the server restarted before the turn's end was recorded, and refused while
+   * that turn is still in flight, since the folder reaches the board only when it ends.
+   */
+  async skillFilesForApproval(proposal2) {
+    const name = skillFolderOf(proposal2);
+    if (name === null || proposal2.skillFiles !== void 0) {
+      return proposal2;
+    }
+    const cannot = `proposal ${proposal2.id} cannot be approved`;
+    const filing = this.turnsInFlight().some((turn2) => turn2.agent === proposal2.proposedBy && proposedFrom(proposal2.filedFrom, turn2));
+    if (filing) {
+      throw new BoardError("INVALID_STATE", `${cannot} until ${proposal2.proposedBy}'s turn that proposed it ends, when the board takes the skill's folder from its home`);
+    }
+    const taken = await this.takeSkillFolderUnlocked(proposal2, name);
+    if (typeof taken === "string") {
+      throw new BoardError("INVALID_STATE", `${cannot}: ${taken}; reject it with that reason`);
+    }
+    return this.recordSkillFiles(proposal2, taken);
+  }
+  /**
+   * Takes the folders of the skills a citizen proposed from a conversation, once the turn there has
+   * ended and its runner has pushed the citizen's home. A proposal whose folder the home does not
+   * give is rejected by the board with the reason, which wakes the proposer to put it right; while
+   * someone is in a turn in the proposal's thread, it stays as it is, and approval meets the reason.
+   */
+  async takeSkillFiles(turn2) {
+    const where = {
+      scope: turn2.project,
+      ...turn2.thread === void 0 ? {} : { thread: turn2.thread },
+      ...turn2.channel === void 0 ? {} : { channel: turn2.channel }
+    };
+    await this.mutex.run(async () => {
+      for (const proposal2 of await this.listProposals()) {
+        const name = skillFolderOf(proposal2);
+        if (name === null || proposal2.status !== "proposed" || proposal2.skillFiles !== void 0 || proposal2.proposedBy !== turn2.agent || !proposedFrom(proposal2.filedFrom, where)) {
+          continue;
+        }
+        const taken = await this.takeSkillFolderUnlocked(proposal2, name);
+        if (typeof taken !== "string") {
+          await this.recordSkillFiles(proposal2, taken);
+          continue;
+        }
+        try {
+          await this.decideUnlocked(SYSTEM_ACTOR, proposal2.id, "rejected", `${taken} when the turn that proposed it ended; propose it again once the folder is there`);
+        } catch (error) {
+          if (!(error instanceof BoardError)) {
+            throw error;
+          }
+        }
+      }
+    });
+  }
+  /** A skill proposal's files with their text, as the board took them; none before then. */
+  async readSkillFiles(proposalId) {
+    const proposal2 = await this.readProposal(proposalId);
+    const dir = this.paths.proposalFiles(proposal2.id);
+    const files = [];
+    for (const entry of proposal2.skillFiles?.files ?? []) {
+      if (!isSafeRelativePath(entry.path)) {
+        continue;
+      }
+      const bytes = await readFile4(path6.join(dir, ...entry.path.split("/"))).catch(() => null);
+      const text = bytes === null || bytes.includes(0) ? null : bytes.toString("utf8");
+      files.push({
+        ...entry,
+        text: text === null ? null : text.slice(0, SKILL_TEXT_LIMIT_CHARS),
+        truncated: text !== null && text.length > SKILL_TEXT_LIMIT_CHARS
+      });
+    }
+    return files;
+  }
   async validateAddAgent(input) {
     if (await exists(this.paths.agentFile(input.name))) {
       throw new BoardError("ALREADY_EXISTS", `agent ${input.name} already exists`);
@@ -7394,67 +7779,70 @@ ${charter.purpose}
    * retired. Validation runs before any write, so an impossible provision fails the decision.
    */
   async decide(actor, proposalId, outcome, reason) {
-    return this.mutex.run(async () => {
-      const proposal2 = await this.readProposal(proposalId);
-      if (proposal2.status !== "proposed") {
-        throw new BoardError("INVALID_STATE", `proposal ${proposalId} is already ${proposal2.status}`);
-      }
-      if (proposal2.proposedBy === actor.name) {
-        throw new BoardError("FORBIDDEN", "a proposer never decides its own proposal");
-      }
-      const approvers = ROLE_KIND_APPROVERS[proposal2.kind];
-      if (!approvers.includes(actor.role)) {
-        throw new BoardError("FORBIDDEN", `a ${proposal2.kind} proposal requires one of: ${approvers.join(", ")}`);
-      }
-      if (outcome === "approved") {
-        await this.validateProvision(proposal2.kind, proposal2.charter);
-      }
-      this.assertNoTurnCut(actor, `proposal ${proposalId} cannot be decided`, (turn2) => turn2.thread === proposalId);
-      if (outcome === "approved" && proposal2.kind === "archive") {
-        await this.assertProjectQuiet(actor, ArchiveProposalSchema.parse(proposal2.charter).project);
-      }
-      const ts = this.now().toISOString();
-      const decision = DecisionSchema.parse({
-        id: this.newId(),
-        proposalId,
-        decidedBy: actor.name,
-        outcome,
-        ...reason === void 0 ? {} : { reason },
-        ts
-      });
-      await writeMarkdown(this.paths.decision(decision.id), decision, reason ?? "");
-      const provision = outcome === "approved" ? await this.executeProvision(actor.name, proposal2) : void 0;
-      const status = outcome === "rejected" ? "rejected" : provision === void 0 ? "approved" : "provisioned";
-      await this.writeProposal({
-        ...proposal2,
-        status,
-        decidedBy: actor.name,
-        decidedAt: ts,
-        ...reason === void 0 ? {} : { reason },
-        ...provision === void 0 ? {} : { provisionedAt: ts, provision }
-      });
-      await this.events.append("proposal.decided", actor.name, {
+    return this.mutex.run(() => this.decideUnlocked(actor, proposalId, outcome, reason));
+  }
+  async decideUnlocked(actor, proposalId, outcome, reason) {
+    const filed = await this.readProposal(proposalId);
+    if (filed.status !== "proposed") {
+      throw new BoardError("INVALID_STATE", `proposal ${proposalId} is already ${filed.status}`);
+    }
+    if (filed.proposedBy === actor.name) {
+      throw new BoardError("FORBIDDEN", "a proposer never decides its own proposal");
+    }
+    const approvers = ROLE_KIND_APPROVERS[filed.kind];
+    if (!approvers.includes(actor.role)) {
+      throw new BoardError("FORBIDDEN", `a ${filed.kind} proposal requires one of: ${approvers.join(", ")}`);
+    }
+    if (outcome === "approved") {
+      await this.validateProvision(filed.kind, filed.charter);
+    }
+    this.assertNoTurnCut(actor, `proposal ${proposalId} cannot be decided`, (turn2) => turn2.thread === proposalId);
+    if (outcome === "approved" && filed.kind === "archive") {
+      await this.assertProjectQuiet(actor, ArchiveProposalSchema.parse(filed.charter).project);
+    }
+    const proposal2 = outcome === "approved" ? await this.skillFilesForApproval(filed) : filed;
+    const ts = this.now().toISOString();
+    const decision = DecisionSchema.parse({
+      id: this.newId(),
+      proposalId,
+      decidedBy: actor.name,
+      outcome,
+      ...reason === void 0 ? {} : { reason },
+      ts
+    });
+    await writeMarkdown(this.paths.decision(decision.id), decision, reason ?? "");
+    const provision = outcome === "approved" ? await this.executeProvision(actor.name, proposal2) : void 0;
+    const status = outcome === "rejected" ? "rejected" : provision === void 0 ? "approved" : "provisioned";
+    await this.writeProposal({
+      ...proposal2,
+      status,
+      decidedBy: actor.name,
+      decidedAt: ts,
+      ...reason === void 0 ? {} : { reason },
+      ...provision === void 0 ? {} : { provisionedAt: ts, provision }
+    });
+    await this.events.append("proposal.decided", actor.name, {
+      proposalId,
+      outcome,
+      kind: proposal2.kind,
+      proposedBy: proposal2.proposedBy,
+      ...proposal2.filedFrom === void 0 ? {} : { filedFrom: proposal2.filedFrom }
+    });
+    if (provision !== void 0) {
+      await this.events.append("proposal.provisioned", actor.name, {
         proposalId,
-        outcome,
         kind: proposal2.kind,
-        proposedBy: proposal2.proposedBy,
-        ...proposal2.filedFrom === void 0 ? {} : { filedFrom: proposal2.filedFrom }
+        ...provision
       });
-      if (provision !== void 0) {
-        await this.events.append("proposal.provisioned", actor.name, {
-          proposalId,
-          kind: proposal2.kind,
-          ...provision
-        });
-      }
-      const verdict = outcome === "approved" ? "Approved" : "Rejected";
-      const why = reason === void 0 ? "" : ` Reason: ${reason}.`;
-      const result = provision === void 0 ? "" : ` Provisioned: ${Object.entries(provision).map(([key, value]) => `${key} ${plain(value)}`).join(", ")}.`;
-      const thread2 = await this.proposalThreadUnlocked(actor.name, proposal2);
-      await this.appendThreadMessage(actor.name, thread2.id, `${verdict}: ${describeCharter(proposal2.kind, proposal2.charter)}.${why}${result}`, { step: { action: outcome } });
-      await this.endThreadOf(proposalId, actor.name, outcome);
-      return decision;
-    });
+    }
+    const verdict = outcome === "approved" ? "Approved" : "Rejected";
+    const why = reason === void 0 ? "" : ` Reason: ${reason}.`;
+    const result = provision === void 0 ? "" : ` Provisioned: ${Object.entries(provision).map(([key, value]) => `${key} ${plain(value)}`).join(", ")}.`;
+    const thread2 = await this.proposalThreadUnlocked(actor.name, proposal2);
+    const post = `${verdict}: ${describeCharter(proposal2.kind, proposal2.charter)}.${why}${result}`;
+    await this.appendThreadMessage(actor.name, thread2.id, actor.name === SYSTEM_ACTOR.name ? withoutMentions(post) : post, { step: { action: outcome } });
+    await this.endThreadOf(proposalId, actor.name, outcome);
+    return decision;
   }
   /** The opener, the people of its subject, and anyone who posted in it; mentions reach the rest. */
   async participatesInThread(actor, thread2, threads) {
@@ -7569,6 +7957,23 @@ ${charter.purpose}
       yield* this.threadMessagesIn(this.paths.threads(slug), since);
     }
   }
+  /** Every folder that holds messages: each channel's and each thread's, in the society and every project. */
+  async *messageDirs() {
+    for (const channel of await listDirs(this.paths.societyChannels())) {
+      yield this.paths.societyChannel(channel);
+    }
+    for (const id of await listDirs(this.paths.societyThreads())) {
+      yield this.paths.threadMessages(this.paths.societyThreads(), id);
+    }
+    for (const slug of await listDirs(this.paths.projects())) {
+      for (const channel of await listDirs(this.paths.projectChannels(slug))) {
+        yield this.paths.projectChannel(slug, channel);
+      }
+      for (const id of await listDirs(this.paths.threads(slug))) {
+        yield this.paths.threadMessages(this.paths.threads(slug), id);
+      }
+    }
+  }
   async *threadMessagesIn(threads, since) {
     for (const id of await listDirs(threads)) {
       yield* await this.readMessagesIn(this.paths.threadMessages(threads, id), since);
@@ -7585,7 +7990,7 @@ function globals() {
 function print(value, human) {
   console.log(globals().json ? JSON.stringify(value, null, 2) : human());
 }
-async function open() {
+async function open2() {
   return Board.open(globals().data);
 }
 async function actorFor(board, as) {
@@ -7631,7 +8036,7 @@ user.command("token").description("Issue the user a new token and print it once;
   if (!opts.rotate) {
     throw new BoardError("VALIDATION", "the board keeps only a hash of the user token, so it cannot show it again; `user token --rotate` issues a new one");
   }
-  const board = await open();
+  const board = await open2();
   const userToken = await board.rotateUserToken();
   print({ userToken }, () => [
     `User token (shown once): ${userToken}`,
@@ -7640,7 +8045,7 @@ user.command("token").description("Issue the user a new token and print it once;
 });
 var project = program.command("project").description("Manage projects");
 project.command("add <slug>").description("Add a project with its default channels").option("--name <name>", "display name").option("--repo <url>", "git remote").option("--on-done <effect>", "what finishing a task does: none, or merge its branch").action(async (slug, opts) => {
-  const board = await open();
+  const board = await open2();
   const added = await board.addProject(board.userActor(), {
     slug,
     name: opts.name,
@@ -7650,7 +8055,7 @@ project.command("add <slug>").description("Add a project with its default channe
   print(added, () => `Project ${added.slug} added with channels ${added.channels.join(", ")}`);
 });
 project.command("configure <slug>").description("Set a project's completion effect").requiredOption("--on-done <effect>", "none, or merge").option("--as <agent>", "act as this agent instead of the user").action(async (slug, opts) => {
-  const board = await open();
+  const board = await open2();
   const configured = await board.configureProject(await actorFor(board, opts.as), {
     project: slug,
     on_done: CompletionEffectSchema.parse(opts.onDone)
@@ -7658,7 +8063,7 @@ project.command("configure <slug>").description("Set a project's completion effe
   print(configured, () => `Project ${configured.slug}: on done ${configured.onDone}`);
 });
 project.command("archive <slug>").description("Archive a project with no task in play: its members leave and its threads close").requiredOption("--reason <text>", "why the project is archived").action(async (slug, opts) => {
-  const board = await open();
+  const board = await open2();
   const archived = await board.archiveProject(board.userActor(), {
     project: slug,
     reason: opts.reason
@@ -7666,13 +8071,13 @@ project.command("archive <slug>").description("Archive a project with no task in
   print(archived, () => `Project ${archived.slug} archived`);
 });
 project.command("list").description("List projects").action(async () => {
-  const board = await open();
+  const board = await open2();
   const projects = await board.listProjects();
   print(projects, () => projects.map((p) => p.archived === void 0 ? `${p.slug}	${p.name}	members: ${p.members.join(", ") || "none"}` : `${p.slug}	${p.name}	archived ${p.archived.at} by ${p.archived.by}`).join("\n"));
 });
 var runner = program.command("runner").description("Manage runners");
 runner.command("add <name>").description("Register a runner and print its token once").action(async (name) => {
-  const board = await open();
+  const board = await open2();
   const { runner: added, token } = await board.addRunner(board.userActor(), name);
   print({ runner: added, token }, () => [
     `Runner ${added.name} added`,
@@ -7681,13 +8086,13 @@ runner.command("add <name>").description("Register a runner and print its token
   ].join("\n"));
 });
 runner.command("list").description("List runners and what they offer").action(async () => {
-  const board = await open();
+  const board = await open2();
   const runners = await board.listRunners();
   print(runners, () => runners.length === 0 ? "No runners yet; add one with `runner add <name>`." : runners.map((each) => `${each.name}  ${each.status}  ${each.os}${each.version === void 0 ? "" : `  v${each.version}`}  ${each.clis.join(",") || "no CLIs yet"}${each.capabilities.length === 0 ? "" : `  ${each.capabilities.join(",")}`}`).join("\n"));
 });
 var agent = program.command("agent").description("Manage agents");
 agent.command("add <name>").description("Add an agent and print its board token once").requiredOption("--role <role>", "role charter name").option("--cli <cli>", "claude or codex").option("--model <model>", "model to run the CLI with; the CLI's own default otherwise").option("--runner <name>", "runner preferred for its turns; any with its CLI otherwise").option("-p, --project <slug...>", "project memberships").action(async (name, opts) => {
-  const board = await open();
+  const board = await open2();
   const cli = opts.cli === void 0 ? null : CliKindSchema.parse(opts.cli);
   const { agent: added, token } = await board.addAgent(board.userActor(), {
     name,
@@ -7700,7 +8105,7 @@ agent.command("add <name>").description("Add an agent and print its board token
   print({ agent: added, token }, () => [`Agent ${added.name} added as ${added.role}`, `Token (shown once): ${token}`].join("\n"));
 });
 agent.command("runner <name> [runner]").description("Show or set the runner a citizen's work outside any project runs on; `none` pins it again on its next turn").action(async (name, chosen) => {
-  const board = await open();
+  const board = await open2();
   if (chosen === void 0) {
     const current = await board.readAgent(name);
     print({ agent: name, homeRunner: current.homeRunner ?? null }, () => current.homeRunner === void 0 ? `${name} is not pinned; its next turn outside a project pins it` : `${name} runs on ${current.homeRunner}`);
@@ -7710,7 +8115,7 @@ agent.command("runner <name> [runner]").description("Show or set the runner a ci
   print({ agent: name, homeRunner: updated.homeRunner ?? null }, () => updated.homeRunner === void 0 ? `${name} will be pinned on its next turn` : `${name} runs on ${updated.homeRunner} from its next turn`);
 });
 agent.command("list").description("List agents").action(async () => {
-  const board = await open();
+  const board = await open2();
   const agents = await board.listAgents();
   const members = await board.listMembers();
   print(agents, () => agents.map((a) => {
@@ -7719,28 +8124,28 @@ agent.command("list").description("List agents").action(async () => {
   }).join("\n"));
 });
 agent.command("model <name> [model]").description("Set the model a member's turns run with, from its next turn; no model means the CLI's default").action(async (name, model) => {
-  const board = await open();
+  const board = await open2();
   const updated = await board.setAgentModel(board.userActor(), name, model ?? null);
   print(updated, () => `${updated.name} runs with ${updated.model ?? "its CLI's default model"} from its next turn`);
 });
 agent.command("effort <name> [effort]").description("Set the reasoning effort a member's turns run with, from its next turn, such as high; no effort means the model's default").action(async (name, effort) => {
-  const board = await open();
+  const board = await open2();
   const updated = await board.setAgentEffort(board.userActor(), name, effort ?? null);
   print(updated, () => `${updated.name} runs with ${updated.effort === void 0 ? "its model's default effort" : `${updated.effort} effort`} from its next turn`);
 });
 agent.command("retire <name>").description("Retire a member: no more wakes, claims released, token revoked, sessions archived").requiredOption("--reason <text>", "why").action(async (name, opts) => {
-  const board = await open();
+  const board = await open2();
   const retired = await board.retireAgent(board.userActor(), { name, reason: opts.reason });
   print(retired, () => `Agent ${retired.name} retired: ${opts.reason}`);
 });
 var proposal = program.command("proposal").description("Governance proposals");
 proposal.command("list").description("List proposals").action(async () => {
-  const board = await open();
+  const board = await open2();
   const proposals = await board.listProposals();
   print(proposals, () => proposals.length === 0 ? "No proposals." : proposals.map((p) => `${p.id}	${p.kind}	${p.status}	by ${p.proposedBy}`).join("\n"));
 });
 proposal.command("show <id>").description("Show a proposal with its charter and rationale").action(async (id) => {
-  const board = await open();
+  const board = await open2();
   const found = await board.readProposal(id);
   print(found, () => [
     `${found.id}  ${found.kind}  ${found.status}  by ${found.proposedBy}`,
@@ -7750,7 +8155,7 @@ proposal.command("show <id>").description("Show a proposal with its charter and
   ].filter((line) => line.length > 0).join("\n"));
 });
 proposal.command("create").description("Propose a member, role, channel, reallocation, or retirement").requiredOption("--kind <kind>", "member, role, channel, reallocation, or retirement").requiredOption("--charter <json>", "the charter as a JSON object").option("--rationale <text>", "why", "").option("--as <agent>", "act as this agent instead of the user").action(async (opts) => {
-  const board = await open();
+  const board = await open2();
   const created = await board.propose(await actorFor(board, opts.as), {
     kind: ProposalKindSchema.parse(opts.kind),
     charter: parseCharter(opts.charter),
@@ -7759,7 +8164,7 @@ proposal.command("create").description("Propose a member, role, channel, realloc
   print(created, () => `Proposal ${created.id} (${created.kind}) is ${created.status}`);
 });
 proposal.command("approve <id>").description("Approve a proposal; the board provisions it").option("--reason <text>", "a note for the record").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
-  const board = await open();
+  const board = await open2();
   const decision = await board.approve(await actorFor(board, opts.as), {
     proposal_id: id,
     ...opts.reason === void 0 ? {} : { reason: opts.reason }
@@ -7768,7 +8173,7 @@ proposal.command("approve <id>").description("Approve a proposal; the board prov
   print({ decision, proposal: after }, () => `Proposal ${id} approved; it is now ${after.status}`);
 });
 proposal.command("reject <id>").description("Reject a proposal with a reason").requiredOption("--reason <text>", "why").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
-  const board = await open();
+  const board = await open2();
   const decision = await board.reject(await actorFor(board, opts.as), {
     proposal_id: id,
     reason: opts.reason
@@ -7777,14 +8182,14 @@ proposal.command("reject <id>").description("Reject a proposal with a reason").r
 });
 var role = program.command("role").description("Role charters");
 role.command("list").description("List role charters").action(async () => {
-  const board = await open();
+  const board = await open2();
   const roles = await board.listRoles();
   print(roles, () => roles.map((r) => `${r.name}	replicas up to ${r.maxReplicas}	backlog threshold ${r.backlogThreshold}	wakes on ${r.wakeTriggers.join(", ") || "direct wakes only"}`).join("\n"));
 });
 role.command("add <name>").description("Write a new role charter directly as the user").requiredOption("--purpose <text>", "what the role is for; its members read this every turn").option("--verbs <verbs...>", "board verbs granted; the member verbs by default").option("--triggers <triggers...>", "wakes it opts into: user_post, ops_event, heartbeat", [
   "heartbeat"
 ]).action(async (name, opts) => {
-  const board = await open();
+  const board = await open2();
   const added = await board.setRoleCharter(board.userActor(), {
     name,
     purpose: opts.purpose,
@@ -7794,7 +8199,7 @@ role.command("add <name>").description("Write a new role charter directly as the
   print(added, () => `Role ${added.name} written with ${added.verbs.length} verbs`);
 });
 role.command("set <name>").description("Change a charter directly as the user: scaling cap, threshold, or purpose").option("--max-replicas <n>", "active members of the role per project the scheduler may reach").option("--backlog-threshold <n>", "load per member that adds a replica").option("--purpose <text>", "the charter's purpose").action(async (name, opts) => {
-  const board = await open();
+  const board = await open2();
   const current = await board.readRole(name);
   const updated = await board.setRoleCharter(board.userActor(), {
     ...current,
@@ -7806,7 +8211,7 @@ role.command("set <name>").description("Change a charter directly as the user: s
 });
 var channelCommand = program.command("channel").description("Channels");
 channelCommand.command("add <ref>").description("Open a channel: <name> for the society or <project>/<name>").requiredOption("--purpose <text>", "what the channel is for").option("--as <agent>", "act as this agent instead of the user").action(async (ref, opts) => {
-  const board = await open();
+  const board = await open2();
   const parsed = parseChannelRef(ref);
   const added = await board.addChannel(await actorFor(board, opts.as), {
     project: parsed.project,
@@ -7816,7 +8221,7 @@ channelCommand.command("add <ref>").description("Open a channel: <name> for the
   print({ channel: added }, () => `Channel ${added} opened`);
 });
 channelCommand.command("archive <ref>").description("Archive a channel whose workstream is done, once no task filed there is in play").requiredOption("--reason <text>", "why its work is done").option("--as <agent>", "act as this agent instead of the user").action(async (ref, opts) => {
-  const board = await open();
+  const board = await open2();
   const archived = await board.archiveChannel(await actorFor(board, opts.as), {
     channel: ref,
     reason: opts.reason
@@ -7824,12 +8229,12 @@ channelCommand.command("archive <ref>").description("Archive a channel whose wor
   print(archived, () => `Channel ${ref} archived: ${archived.reason}`);
 });
 program.command("signals").description("Recent operations signals, oldest first").option("--limit <n>", "how many", "50").action(async (opts) => {
-  const board = await open();
+  const board = await open2();
   const signals = await board.listSignals(Number(opts.limit));
   print(signals, () => signals.length === 0 ? "No signals yet." : signals.map((s) => `[${s.ts}] ${s.signal.kind}	${s.signal.summary}`).join("\n"));
 });
 program.command("post <channel> <body>").description("Post a message to a channel, or into one of its threads").option("--as <agent>", "act as this agent instead of the user").option("--thread <threadId>", "post into the thread, which must hang off the channel").action(async (channel, body, opts) => {
-  const board = await open();
+  const board = await open2();
   const who = await actorFor(board, opts.as);
   const message = await board.postMessage(who, {
     channel,
@@ -7839,13 +8244,13 @@ program.command("post <channel> <body>").description("Post a message to a channe
   print(message, () => `Posted ${message.id} to ${message.channel}${message.thread === void 0 ? "" : ` (thread ${message.thread})`}`);
 });
 program.command("ask <text>").description("Post to the society's general channel as the user; the front desk routes it").action(async (text) => {
-  const board = await open();
+  const board = await open2();
   const message = await board.postMessage(board.userActor(), { channel: "general", body: text });
   print(message, () => `Posted ${message.id} to general; the concierge wakes on it`);
 });
 var task = program.command("task").description("Manage tasks");
 task.command("create <project> <title>").description("Create a task with a plan, or with one stage anyone in the project may take").option("--body <text>", "task body", "").option("--parent <id>", "parent task id").option("--plan <json>", `stages, for example '[{"name":"analysis","role":"analyst"}]'`).option("--channel <name>", "the project's channel to file it in, such as a release's", "general").option("--as <agent>", "act as this agent instead of the user").action(async (projectSlug, title, opts) => {
-  const board = await open();
+  const board = await open2();
   const who = await actorFor(board, opts.as);
   const created = await board.createTask(who, {
     project: projectSlug,
@@ -7861,17 +8266,17 @@ task.command("create <project> <title>").description("Create a task with a plan,
   ].join("\n"));
 });
 task.command("claim <id>").description("Hold the task's current stage").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
-  const board = await open();
+  const board = await open2();
   const claimed = await board.claimTask(await actorFor(board, opts.as), { task_id: id });
   print(claimed, () => `Stage ${claimed.stage} of task ${claimed.id} held by ${claimed.claimedBy ?? "?"} until ${claimed.leaseExpiresAt ?? "?"}`);
 });
 task.command("release <id>").description("Let go of the stage held on a task").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
-  const board = await open();
+  const board = await open2();
   const released = await board.releaseTask(await actorFor(board, opts.as), { task_id: id });
   print(released, () => `Stage ${released.stage} of task ${released.id} released`);
 });
 task.command("advance <id>").description("Finish the current stage; past the last one the task is done").option("--note <text>", "what was done, posted to the task's thread").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
-  const board = await open();
+  const board = await open2();
   const advanced = await board.advanceTask(await actorFor(board, opts.as), {
     task_id: id,
     ...opts.note === void 0 ? {} : { note: opts.note }
@@ -7880,7 +8285,7 @@ task.command("advance <id>").description("Finish the current stage; past the las
 ${describePlan(advanced)}`);
 });
 task.command("plan <id> <stages>").description("Reshape the stages ahead: pass existing stages with their id to keep them, new ones without").option("--on-done <effect>", "override the completion effect for this task").option("--as <agent>", "act as this agent instead of the user").action(async (id, stages, opts) => {
-  const board = await open();
+  const board = await open2();
   const planned = await board.planTask(await actorFor(board, opts.as), {
     task_id: id,
     stages: PlanEditSchema.parse(JSON.parse(stages)),
@@ -7889,7 +8294,7 @@ task.command("plan <id> <stages>").description("Reshape the stages ahead: pass e
   print(planned, () => describePlan(planned));
 });
 task.command("update <id>").description("Send a task back to an earlier stage, abandon it, or set blockers, with a note for its thread").option("--stage <stageId>", "move back to this earlier stage").option("--abandon", "abandon the task", false).option("--note <text>", "a note, posted to the task's thread").option("--blocked-by <ids...>", "task ids this task waits on").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
-  const board = await open();
+  const board = await open2();
   const updated = await board.updateTask(await actorFor(board, opts.as), {
     task_id: id,
     ...opts.stage === void 0 ? {} : { stage: opts.stage },
@@ -7900,7 +8305,7 @@ task.command("update <id>").description("Send a task back to an earlier stage, a
   print(updated, () => `Task ${updated.id} is ${updated.status} at ${updated.stage}`);
 });
 task.command("show <id>").description("Show a task with its plan and its thread").action(async (id) => {
-  const board = await open();
+  const board = await open2();
   const found = await board.getTask(board.userActor(), { task_id: id });
   const threadState = await board.readThread(id).then((t) => t.state).catch(() => "none");
   const said = found.messages.map((message) => {
@@ -7920,7 +8325,7 @@ ${message.body.trim()}
   ].join("\n"));
 });
 task.command("list <project>").description("List a project's tasks with their current stage").action(async (projectSlug) => {
-  const board = await open();
+  const board = await open2();
   const tasks = await board.listTasks(projectSlug);
   print(tasks, () => tasks.length === 0 ? "No tasks." : tasks.map((t) => {
     const stage = t.stages[stageIndex(t, t.stage)];
@@ -7929,7 +8334,7 @@ task.command("list <project>").description("List a project's tasks with their cu
 });
 var thread = program.command("thread").description("Manage threads");
 thread.command("open [taskId]").description("Open a thread on a task, on a proposal, or on a channel with a title").option("--proposal <id>", "open the proposal's thread").option("--channel <ref>", "the channel it hangs off; required for a topic").option("--title <text>", "the thread's title; required for a topic").option("--as <agent>", "act as this agent instead of the user").action(async (taskId, opts) => {
-  const board = await open();
+  const board = await open2();
   const opened = await board.openThread(await actorFor(board, opts.as), {
     ...taskId === void 0 ? {} : { task_id: taskId },
     ...opts.proposal === void 0 ? {} : { proposal_id: opts.proposal },
@@ -7939,7 +8344,7 @@ thread.command("open [taskId]").description("Open a thread on a task, on a propo
   print(opened, () => `Thread ${opened.id} opened on ${opened.channel}: ${opened.title}`);
 });
 thread.command("close <threadId>").description("Close a thread with a summary posted to its channel").requiredOption("--summary <text>", "closure summary").option("--as <agent>", "act as this agent instead of the user").action(async (threadId, opts) => {
-  const board = await open();
+  const board = await open2();
   const summary = await board.closeThread(await actorFor(board, opts.as), {
     thread_id: threadId,
     summary: opts.summary
@@ -7947,7 +8352,7 @@ thread.command("close <threadId>").description("Close a thread with a summary po
   print(summary, () => `Thread closed; summary posted as ${summary.id} to ${summary.channel}`);
 });
 thread.command("list").description("List threads, the society's first, then each project's").option("--open", "only open threads", false).action(async (opts) => {
-  const board = await open();
+  const board = await open2();
   const threads = (await board.listThreads()).filter((t) => !opts.open || t.state === "open");
   print(threads, () => threads.length === 0 ? "No threads." : threads.map((t) => {
     const about = t.subject === void 0 ? "topic" : t.subject.kind;
@@ -7955,7 +8360,7 @@ thread.command("list").description("List threads, the society's first, then each
   }).join("\n"));
 });
 thread.command("show <threadId>").description("Show a thread and its messages").action(async (threadId) => {
-  const board = await open();
+  const board = await open2();
   const found = await board.readThread(threadId);
   const messages = await board.listThread(threadId);
   print({ thread: found, messages }, () => [
@@ -7966,17 +8371,17 @@ thread.command("show <threadId>").description("Show a thread and its messages").
   ].join("\n"));
 });
 program.command("pause").description("Stop all wakeups; turns in flight finish").action(async () => {
-  const board = await open();
+  const board = await open2();
   await board.setPaused(board.userActor(), true);
   print({ paused: true }, () => "Society paused");
 });
 program.command("resume").description("Allow wakeups again").action(async () => {
-  const board = await open();
+  const board = await open2();
   await board.setPaused(board.userActor(), false);
   print({ paused: false }, () => "Society resumed");
 });
 program.command("society").description("The society's settings").command("timezone [zone]").description("Show the society's time zone, or set it: crons that name none are read in it").action(async (zone) => {
-  const board = await open();
+  const board = await open2();
   const society = zone === void 0 ? await board.society() : await board.setTimezone(board.userActor(), zone);
   print({ timezone: society.timezone }, () => `Time zone: ${society.timezone}`);
 });
@@ -7992,13 +8397,13 @@ function describeCron(cron2, timeZone) {
 }
 var cron = program.command("cron").description("Crons that wake citizens on a clock");
 cron.command("list").description("List crons, ended ones too with --all").option("--all", "include ended crons", false).action(async (opts) => {
-  const board = await open();
+  const board = await open2();
   const { timezone } = await board.society();
   const crons = (await board.listCrons()).filter((each) => opts.all || each.ended === void 0);
   print(crons, () => crons.length === 0 ? "No crons." : crons.map((each) => describeCron(each, timezone)).join("\n"));
 });
 cron.command("add <agent> <title>").description("Set a cron that wakes a citizen, with a note on what to do then").requiredOption("--note <text>", "what the citizen does when it fires").option("--cron <expression>", "five fields: minute hour day-of-month month day-of-week").option("--timezone <zone>", "the zone the expression is read in; the society's otherwise").option("--at <time>", "one time to fire, with its offset, instead of --cron").option("--project <slug>", "where it fires: a project the citizen is in, or society").option("--thread <id>", "an open thread there whose conversation it fires in").option("--channel <name>", "an open channel there, other than general, whose conversation it fires in").option("--as <agent>", "act as this agent instead of the user").action(async (agentName, title, opts) => {
-  const board = await open();
+  const board = await open2();
   const created = await board.createCron(await actorFor(board, opts.as), {
     title,
     note: opts.note,
@@ -8018,7 +8423,7 @@ for (const [name, paused] of [
   ["resume", false]
 ]) {
   cron.command(`${name} <id>`).description(paused ? "Pause a cron" : "Resume a paused cron from its next time").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
-    const board = await open();
+    const board = await open2();
     const updated = await board.updateCron(await actorFor(board, opts.as), {
       cron_id: id,
       paused
@@ -8028,7 +8433,7 @@ for (const [name, paused] of [
   });
 }
 cron.command("remove <id>").description("End a cron for good").requiredOption("--reason <text>", "why it ends").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
-  const board = await open();
+  const board = await open2();
   const removed = await board.removeCron(await actorFor(board, opts.as), {
     cron_id: id,
     reason: opts.reason
@@ -8037,31 +8442,32 @@ cron.command("remove <id>").description("End a cron for good").requiredOption("-
 });
 var knowledge = program.command("knowledge").description("Shared knowledge, by project or society");
 knowledge.command("list [project]").description("List knowledge topics of a project, or of the society when no project is given").action(async (projectSlug) => {
-  const board = await open();
+  const board = await open2();
   const topics = await board.listKnowledge(projectSlug ?? null);
-  print(topics, () => topics.length === 0 ? "No knowledge yet." : topics.map((t) => `${t.topic}	updated by ${t.updatedBy} at ${t.updatedAt}`).join("\n"));
+  print(topics, () => topics.length === 0 ? "No knowledge yet." : topics.map((t) => `${t.topic}	revision ${t.revision}, updated by ${t.updatedBy} at ${t.updatedAt}`).join("\n"));
 });
 knowledge.command("show <topic>").description("Print a knowledge topic").option("--project <slug>", "the project's topic instead of the society's").action(async (topic, opts) => {
-  const board = await open();
+  const board = await open2();
   const found = (await board.listKnowledge(opts.project ?? null)).find((t) => t.topic === topic);
   if (found === void 0) {
     throw new BoardError("NOT_FOUND", `no knowledge topic ${topic}`);
   }
   print(found, () => found.body);
 });
-knowledge.command("write <topic>").description("Write a knowledge topic as the user, from a file or standard input").option("--project <slug>", "the project's topic instead of the society's").option("--file <path>", "read the body from this file instead of standard input").option("--as <agent>", "act as this agent instead of the user").action(async (topic, opts) => {
-  const board = await open();
-  const body = opts.file === void 0 ? await readStdin() : await readFile6(path7.resolve(opts.file), "utf8");
+knowledge.command("write <topic>").description("Write a knowledge topic as the user, from a file or standard input").requiredOption("--revision <n>", "the revision it replaces, as knowledge list shows it; 0 for a new topic").option("--project <slug>", "the project's topic instead of the society's").option("--file <path>", "read the body from this file instead of standard input").option("--as <agent>", "act as this agent instead of the user").action(async (topic, opts) => {
+  const board = await open2();
+  const body = opts.file === void 0 ? await readStdin() : await readFile5(path7.resolve(opts.file), "utf8");
   const written = await board.writeKnowledge(await actorFor(board, opts.as), {
     project: opts.project ?? null,
     topic,
-    body
+    body,
+    revision: Number(opts.revision)
   });
-  print(written, () => `Wrote ${written.topic} for ${written.project ?? "the society"}`);
+  print(written, () => `Wrote ${written.topic} for ${written.project ?? "the society"} at revision ${written.revision}`);
 });
 var skill = program.command("skill").description("Skills promoted to the society");
 skill.command("list").description("List the society's skills, and each member's own").action(async () => {
-  const board = await open();
+  const board = await open2();
   const society = await board.listSocietySkills();
   const own = [];
   for (const member of await board.listAgents()) {
@@ -8076,7 +8482,7 @@ skill.command("list").description("List the society's skills, and each member's
   ].join("\n") || "No skills yet.");
 });
 skill.command("remove <name>").description("Remove a skill from the society's skills; its text is set aside, not destroyed").requiredOption("--reason <text>", "why it is wrong, superseded, or no longer used").option("--as <agent>", "act as this agent instead of the user").action(async (name, opts) => {
-  const board = await open();
+  const board = await open2();
   const removed = await board.removeSkill(await actorFor(board, opts.as), {
     name,
     reason: opts.reason
@@ -8085,13 +8491,13 @@ skill.command("remove <name>").description("Remove a skill from the society's sk
 });
 var turn = program.command("turn").description("Turn operations");
 turn.command("digest <agent>").description("Show the unread messages the agent's next turn opens with, in one scope or all; the cursors stay put").option("--limit <n>", "maximum messages", "50").option("--project <slug>", "the scope whose turn to show: a project, or society").action(async (agentName, opts) => {
-  const board = await open();
+  const board = await open2();
   const actor = await board.actorFor(agentName);
   const digest = await board.readDigest(opts.project === void 0 ? actor : { ...actor, scope: opts.project }, { advance: false, limit: Number(opts.limit) });
   print(digest, () => digest.messages.length === 0 ? "No unread messages." : digest.messages.map((m) => `[${m.ts}] ${m.channel}${m.thread === void 0 ? "" : ` (thread ${m.thread})`} @${m.author}: ${m.body.trim()}`).join("\n"));
 });
 turn.command("run <agent>").description("Enqueue a manual wake for an agent on a project, or a reflection turn").requiredOption("--project <slug>", "project to act on, or society for a society-scope turn").option("--reason <text>", "why", "manual wake from the admin CLI").option("--reflect", "a reflection turn instead of a working turn", false).action(async (agentName, opts) => {
-  const board = await open();
+  const board = await open2();
   const event = await board.requestWake(board.userActor(), {
     agent: agentName,
     project: opts.project,