@kubitnodes/stellaris 0.3.18 → 0.3.19

package/dist/cli/index.js

@@ -6,7 +6,7 @@ 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 readFile5, rename as rename3, rm as rm2, stat as stat2, writeFile as writeFile4 } from "node:fs/promises";
 import path6 from "node:path";
 import { decodeTime, monotonicFactory } from "ulid";
 import { z as z13 } from "zod";
@@ -622,7 +622,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 +749,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 +772,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 +798,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 +902,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 +1005,7 @@ var BOARD_EVENT_TYPES = [
   "proposal.created",
   "proposal.decided",
   "proposal.provisioned",
+  "proposal.files_taken",
   "channel.added",
   "channel.archived",
   "role.added",
@@ -1388,6 +1412,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 +1733,7 @@ var RunnerConfigSchema = z11.object({
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.3.18";
+var STELLARIS_VERSION = "0.3.19";
 
 // packages/board-core/dist/errors.js
 var BoardError = class extends Error {
@@ -1760,7 +1787,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 };
@@ -1947,13 +1976,14 @@ var FileTree = class {
       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");
       this.hashes.set(absolute, { mtimeMs: info.mtimeMs, size: info.size, sha });
-      return sha;
+      return fileVersion(sha, executable);
     } catch (error) {
       if (isMissing2(error)) {
         return null;
@@ -2204,6 +2234,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 +2698,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 +2953,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";
@@ -3792,22 +3889,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 stat2(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");
@@ -4521,26 +4637,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 +4695,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 +5746,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 +5765,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,
@@ -6849,7 +6989,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 +7003,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 readFile5(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 +7688,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) {
@@ -8039,7 +8336,7 @@ var knowledge = program.command("knowledge").description("Shared knowledge, by p
 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 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();
@@ -8049,15 +8346,16 @@ knowledge.command("show <topic>").description("Print a knowledge topic").option(
   }
   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) => {
+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 open();
   const body = opts.file === void 0 ? await readStdin() : await readFile6(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 () => {