@kubitnodes/stellaris 0.3.24 → 0.3.25

package/dist/cli/index.js

@@ -715,7 +715,6 @@ var ReallocationProposalSchema = z5.object({
   changes: RoleChangesSchema,
   description: z5.string().min(1)
 });
-var LegacyReallocationSchema = z5.object({ description: z5.string().min(1) });
 function applyRoleChanges(role2, changes) {
   return {
     ...role2,
@@ -760,8 +759,7 @@ var ArchiveProposalSchema = z5.object({
 });
 var SkillProposalSchema = z5.object({
   name: NameSchema,
-  summary: z5.string().min(1).max(200),
-  body: z5.string().min(1).optional()
+  summary: z5.string().min(1).max(200)
 });
 var ProposalCharterSchemas = {
   role: RoleCharterSchema,
@@ -838,14 +836,10 @@ function describeCharter(kind, charter) {
     }
     case "reallocation": {
       const parsed = ReallocationProposalSchema.safeParse(charter);
-      if (parsed.success) {
-        const { role: role2, changes, description } = parsed.data;
-        return `reallocation of role ${role2} (${describeRoleChanges(changes)}): ${description}`;
-      }
-      const legacy = LegacyReallocationSchema.safeParse(charter);
-      if (!legacy.success)
+      if (!parsed.success)
         break;
-      return `reallocation: ${legacy.data.description}`;
+      const { role: role2, changes, description } = parsed.data;
+      return `reallocation of role ${role2} (${describeRoleChanges(changes)}): ${description}`;
     }
     case "skill": {
       const parsed = SkillProposalSchema.safeParse(charter);
@@ -1050,12 +1044,10 @@ var VerbInputs = {
     channel: ChannelRefSchema.optional(),
     limit: z7.number().int().positive().max(100).default(20)
   }),
-  /** On a task or a proposal, whose id the thread takes, or on a channel with a title. */
+  /** On a channel with a title; a task's and a proposal's open with them. */
   open_thread: z7.object({
-    task_id: UlidSchema.optional(),
-    proposal_id: UlidSchema.optional(),
-    channel: ChannelRefSchema.optional(),
-    title: z7.string().min(1).max(200).optional()
+    channel: ChannelRefSchema,
+    title: z7.string().min(1).max(200)
   }),
   close_thread: z7.object({ thread_id: UlidSchema, summary: z7.string().min(1) }),
   create_task: z7.object({
@@ -1519,6 +1511,12 @@ var TurnOutcomeSchema = z9.object({
    * runner from before never sends it.
    */
   resumeFailed: ResumeFailureSchema.optional(),
+  /**
+   * Set when the model service turned the turn away for now, as when it was overloaded or failed
+   * on its side, which the scheduler answers by sending the same wake again within minutes. A
+   * runner from before never sends it.
+   */
+  transient: z9.boolean().optional(),
   /** The model the CLI reported, when it reported one. */
   model: z9.string().nullable(),
   work: TurnWorkSchema.nullable(),
@@ -1819,6 +1817,8 @@ var TurnRecordSchema = z10.object({
   stoppedBy: NameSchema.optional(),
   /** Why the CLI could not resume the turn's session, for a turn that failed so. */
   resumeFailed: ResumeFailureSchema.optional(),
+  /** Whether the model service turned the turn away for now: overloaded, or failing on its side. */
+  transient: z10.boolean().optional(),
   /** How many turns in a row, this one included, could not resume the session for a `retry`. */
   resumeRetries: z10.number().int().positive().optional(),
   /** Whether the server dropped the conversation's session after this turn, which the next starts anew. */
@@ -1893,9 +1893,19 @@ var OPS_SIGNAL_KINDS = [
   "runner",
   "home_conflict",
   "stuck_workspace",
-  "cron_failing"
+  "cron_failing",
+  "turn_refused"
 ];
 var OpsSignalKindSchema = z11.enum(OPS_SIGNAL_KINDS);
+var WAKING_SIGNAL_KINDS = [
+  "backlog",
+  "role_gap",
+  "churn",
+  "stale_thread",
+  "idle_member",
+  "blocked_capability",
+  "scaled"
+];
 var OpsSignalSchema = z11.object({
   kind: OpsSignalKindSchema,
   /** Identifies the condition, for example `backlog:demo:engineer`, so a persisting one is not logged again every pass. */
@@ -1908,8 +1918,15 @@ var OpsSignalSchema = z11.object({
   project: NameSchema.optional(),
   agent: NameSchema.optional(),
   role: NameSchema.optional(),
-  taskId: UlidSchema.optional()
+  taskId: UlidSchema.optional(),
+  /**
+   * Whether this log of the condition wakes the roles charted for `ops_event`, as its publisher
+   * decided: the operations pass wakes them when a condition is new, and again only at the steps
+   * it names, not at every repeat. Absent, the kind decides.
+   */
+  wakes: z11.boolean().optional()
 });
+var WAKING = new Set(WAKING_SIGNAL_KINDS);
 
 // packages/shared/dist/metrics.js
 import { z as z12 } from "zod";
@@ -2067,7 +2084,7 @@ var RunnerConfigSchema = z13.object({
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.3.24";
+var STELLARIS_VERSION = "0.3.25";
 
 // packages/shared/dist/mentions.js
 import { parse, postprocess, preprocess } from "micromark";
@@ -3395,7 +3412,7 @@ var BoardPaths = class {
 
 // packages/board-core/dist/skill-folder.js
 import { constants } from "node:fs";
-import { lstat, open as open2, readdir as readdir3, realpath } from "node:fs/promises";
+import { lstat, open as open2, readdir as readdir3, readlink, realpath } from "node:fs/promises";
 import path6 from "node:path";
 var SKILL_TEXT_LIMIT_CHARS = 1e5;
 var SKILL_TEXT_LIMIT_BYTES = SKILL_TEXT_LIMIT_CHARS * 4;
@@ -3410,6 +3427,13 @@ function inside(root, file) {
   const relative = path6.relative(root, file);
   return relative !== ".." && !relative.startsWith(`..${path6.sep}`) && !path6.isAbsolute(relative);
 }
+async function handleInside(root, handle) {
+  if (process.platform !== "linux") {
+    return true;
+  }
+  const file = await readlink(`/proc/self/fd/${handle.fd}`).catch(() => null);
+  return file !== null && inside(root, file);
+}
 async function walk(root, prefix, found) {
   const entries = await readdir3(path6.join(root, ...prefix === "" ? [] : prefix.split("/")), {
     withFileTypes: true
@@ -3444,6 +3468,9 @@ async function readEntry(root, relative) {
     return null;
   }
   try {
+    if (!await handleInside(root, handle)) {
+      return null;
+    }
     const stats = await handle.stat();
     if (!stats.isFile()) {
       return null;
@@ -3514,17 +3541,16 @@ var SignInsSchema = z16.object({
   signIns: z16.array(z16.object({
     tokenHash: z16.string().min(1),
     login: z16.string().min(1),
-    /** The account's picture at the identity provider; sign-ins from before it have none. */
+    /** The account's picture, when GitHub gave one on its own avatar host. */
     avatarUrl: z16.url().optional(),
     createdAt: IsoDateTimeSchema,
     expiresAt: IsoDateTimeSchema
   })).default([])
 });
-var TurnStartPayloadSchema = z16.object({ project: NameSchema, turnId: UlidSchema.optional() });
+var TurnStartPayloadSchema = z16.object({ turnId: UlidSchema });
 var CursorsSchema = z16.object({
   digest: z16.string().nullable(),
   scopes: z16.record(z16.string(), z16.string()).default({}),
-  threadsFrom: z16.record(z16.string(), z16.string().nullable()).default({}),
   channelsFrom: z16.record(z16.string(), z16.string().nullable()).default({}),
   placesFrom: z16.record(z16.string(), z16.string().nullable()).default({}),
   /** How far a work role has read news, which goes to whichever of its general conversations reads first. */
@@ -3533,7 +3559,6 @@ var CursorsSchema = z16.object({
 var NO_CURSORS = {
   digest: null,
   scopes: {},
-  threadsFrom: {},
   channelsFrom: {},
   placesFrom: {}
 };
@@ -3557,10 +3582,6 @@ function placeStart(cursors, scope) {
   const from = cursors.placesFrom[scope];
   return from === void 0 ? cursors.digest : from;
 }
-function threadStart(cursors, scope) {
-  const from = cursors.threadsFrom[scope];
-  return from === void 0 ? cursors.digest : from;
-}
 function newsStart(cursors) {
   if (cursors.news !== void 0) {
     return cursors.news;
@@ -3572,7 +3593,7 @@ function cursorOf(cursors, scope, part = null) {
   if (part === null) {
     return cursors.scopes[scope] ?? cursors.digest;
   }
-  return cursors.scopes[conversationKey(scope, part)] ?? (part.startsWith("#") ? channelStart(cursors, scope) : part.startsWith("~") ? placeStart(cursors, scope) : threadStart(cursors, scope));
+  return cursors.scopes[conversationKey(scope, part)] ?? (part.startsWith("#") ? channelStart(cursors, scope) : part.startsWith("~") ? placeStart(cursors, scope) : cursors.digest);
 }
 function byId(a, b) {
   return a.message.id < b.message.id ? -1 : a.message.id > b.message.id ? 1 : 0;
@@ -3593,7 +3614,7 @@ function skillFolderOf(proposal2) {
     return null;
   }
   const parsed = SkillProposalSchema.safeParse(proposal2.charter);
-  return parsed.success && parsed.data.body === void 0 ? parsed.data.name : null;
+  return parsed.success ? parsed.data.name : null;
 }
 function proposedFrom(origin, where) {
   return origin !== void 0 && origin.scope === where.scope && origin.thread === where.thread && origin.channel === where.channel && origin.place === where.place;
@@ -3608,28 +3629,6 @@ var FRONT_DESK_TRIGGER = "user_post";
 var OPS_CHANNELS = ["governance"];
 var FRONT_DESK_CHANNELS = [ASK_CHANNEL];
 var AlignmentsSchema = z16.object({ applied: z16.array(z16.string()).default([]) });
-var FOLLOW_DECISIONS = "ops-readers-follow-decisions";
-var THREAD_RECORDS = "threads-as-records";
-var DIGEST_CURSORS = "digest-replaces-inbox";
-var TASK_RETURNS = "task-returns-recorded";
-var OPS_CHANNEL_RETIRED = "ops-channel-retired";
-var DECISIONS_CHANNEL_RETIRED = "decisions-channel-retired";
-var THREAD_CONVERSATIONS = "thread-conversations";
-var ASKS_CHANNEL_OPENED = "asks-channel-opened";
-var KNOWLEDGE_REMOVAL = "knowledge-removal-granted";
-var CHANNEL_CONVERSATIONS = "channel-conversations";
-var PLACE_CONVERSATIONS = "place-conversations";
-var DASHBOARD_UPDATES = "dashboard-updates-granted";
-var CRON_VERBS = "cron-verbs-granted";
-var KNOWLEDGE_NOTICES = "knowledge-notices";
-var IMAGE_UPLOADS = "image-uploads-granted";
-var KnowledgeEventSchema = z16.object({
-  topic: NameSchema,
-  project: NameSchema.nullable(),
-  replaced: z16.boolean().optional()
-});
-var CRON_VERB_NAMES = ["create_cron", "update_cron", "remove_cron"];
-var OLD_DASHBOARD_LINE = "Agents may edit this file. It is rendered by the board UI.";
 var DASHBOARD_LINE = "The project's members keep this page current with update_dashboard.";
 var PLANNING_ROLES = [USER_ROLE, "steward", "concierge"];
 var REALLOCATING_ROLES = [USER_ROLE, "steward", "concierge"];
@@ -3649,9 +3648,9 @@ function sentence(summary) {
   return summary.trim().replace(/\.+$/, "");
 }
 function skillSummary(data, body) {
-  const fromFrontmatter = data["description"] ?? data["summary"];
-  if (typeof fromFrontmatter === "string" && fromFrontmatter.trim().length > 0) {
-    return fromFrontmatter.trim();
+  const description = data["description"];
+  if (typeof description === "string" && description.trim().length > 0) {
+    return description.trim();
   }
   return body.split("\n").map((line) => line.trim()).find((line) => line.length > 0 && !line.startsWith("#")) ?? "";
 }
@@ -3804,390 +3803,22 @@ var Board = class _Board {
     return board;
   }
   /**
-   * Applies each one-time alignment an existing society has not had yet. Once applied it is not
-   * repeated, so a member that later chooses otherwise keeps its choice.
+   * Applies each one-time alignment an existing society has not had yet, and remembers it, so a
+   * member that later chooses otherwise keeps its choice. A new alignment is a name and a method in
+   * this list; once every board has applied it, both are deleted. None is pending.
    */
   async applyAlignments() {
+    const alignments = [];
     const file = path7.join(this.paths.state(), "alignments.json");
     const { applied } = await exists(file) ? await readJson(file, AlignmentsSchema) : { applied: [] };
-    const pending = [
-      FOLLOW_DECISIONS,
-      THREAD_RECORDS,
-      DIGEST_CURSORS,
-      TASK_RETURNS,
-      OPS_CHANNEL_RETIRED,
-      DECISIONS_CHANNEL_RETIRED,
-      THREAD_CONVERSATIONS,
-      ASKS_CHANNEL_OPENED,
-      KNOWLEDGE_REMOVAL,
-      CHANNEL_CONVERSATIONS,
-      DASHBOARD_UPDATES,
-      CRON_VERBS,
-      KNOWLEDGE_NOTICES,
-      IMAGE_UPLOADS,
-      PLACE_CONVERSATIONS
-    ].filter((name) => !applied.includes(name));
+    const pending = alignments.filter(({ name }) => !applied.includes(name));
     if (pending.length === 0) {
       return;
     }
-    if (pending.includes(FOLLOW_DECISIONS)) {
-      await this.followDecisions();
-    }
-    if (pending.includes(THREAD_RECORDS)) {
-      await this.recordTaskThreads();
-    }
-    if (pending.includes(DIGEST_CURSORS)) {
-      await this.renameInboxCursors();
-    }
-    if (pending.includes(TASK_RETURNS)) {
-      await this.recordTaskReturns();
-    }
-    if (pending.includes(OPS_CHANNEL_RETIRED)) {
-      await this.retireSocietyChannel("ops");
-    }
-    if (pending.includes(DECISIONS_CHANNEL_RETIRED)) {
-      await this.retireSocietyChannel("decisions");
-    }
-    if (pending.includes(THREAD_CONVERSATIONS)) {
-      await this.startThreadCursors();
-    }
-    if (pending.includes(ASKS_CHANNEL_OPENED)) {
-      await this.openAsksChannel();
-    }
-    if (pending.includes(KNOWLEDGE_REMOVAL)) {
-      await this.grantBeside("write_knowledge", "remove_knowledge");
-    }
-    if (pending.includes(CHANNEL_CONVERSATIONS)) {
-      await this.startChannelCursors();
-    }
-    if (pending.includes(DASHBOARD_UPDATES)) {
-      await this.grantBeside("write_knowledge", "update_dashboard");
-      await this.rewordDashboards();
-    }
-    if (pending.includes(CRON_VERBS)) {
-      await this.grantToEveryRole(CRON_VERB_NAMES);
-    }
-    if (pending.includes(KNOWLEDGE_NOTICES)) {
-      await this.noticeKnowledgeNotes();
-    }
-    if (pending.includes(IMAGE_UPLOADS)) {
-      await this.grantBeside("post_message", "upload_image");
-    }
-    if (pending.includes(PLACE_CONVERSATIONS)) {
-      await this.startPlaceCursors();
-    }
-    await writeJson(file, { applied: [...applied, ...pending] });
-  }
-  /**
-   * Gives each knowledge note from before notes carried their notice the notice it would carry
-   * now. The event log, not the note's words, says which post is one: a knowledge verb appends
-   * its event and then its note under the mutex, so a note is the post right after such an event,
-   * by the same actor, at the top of the general channel of the topic's place. A post written to
-   * look like a note follows no such event and is left as it is.
-   */
-  async noticeKnowledgeNotes() {
-    let before;
-    for (const event of await this.events.readSince(null, Number.POSITIVE_INFINITY)) {
-      const verb = before;
-      before = event;
-      if (event.type !== "message.posted" || verb === void 0 || verb.actor !== event.actor || verb.type !== "knowledge.written" && verb.type !== "knowledge.removed") {
-        continue;
-      }
-      const knowledge2 = KnowledgeEventSchema.safeParse(verb.payload);
-      const id = UlidSchema.safeParse(event.payload["id"]);
-      if (!knowledge2.success || !id.success || (event.payload["thread"] ?? null) !== null || event.payload["channel"] !== channelRef(knowledge2.data.project, "general")) {
-        continue;
-      }
-      const { topic, project: project2, replaced } = knowledge2.data;
-      const file = this.paths.messageFile(this.paths.channelDir(channelRef(project2, "general")), id.data, event.actor);
-      if (!await exists(file)) {
-        continue;
-      }
-      const { data, body, error } = await readLooseMarkdown(file);
-      if (error !== null || data["notice"] !== void 0) {
-        continue;
-      }
-      const notice = {
-        kind: "knowledge",
-        action: verb.type === "knowledge.removed" ? "removed" : replaced === true ? "updated" : "written",
-        topic,
-        project: project2
-      };
-      await writeMarkdown(file, { ...data, notice }, body);
-    }
-  }
-  /**
-   * Grants `verb` once to every charter granting `beside`, the work roles' charters in practice;
-   * seed roles have it from their seed.
-   */
-  async grantBeside(beside, verb) {
-    for (const charter of await this.listRoles()) {
-      if (charter.verbs.includes(beside) && !charter.verbs.includes(verb)) {
-        await this.writeRoleUnlocked(USER_NAME, { ...charter, verbs: [...charter.verbs, verb] }, { verbsAdded: [verb] });
-      }
-    }
-  }
-  /** Grants verbs once to every charter but the user's, which holds every verb already. */
-  async grantToEveryRole(verbs) {
-    for (const charter of await this.listRoles()) {
-      const missing = verbs.filter((verb) => !charter.verbs.includes(verb));
-      if (charter.name !== USER_ROLE && missing.length > 0) {
-        await this.writeRoleUnlocked(USER_NAME, { ...charter, verbs: [...charter.verbs, ...missing] }, { verbsAdded: missing });
-      }
+    for (const { apply } of pending) {
+      await apply();
     }
-  }
-  /** A dashboard still saying agents may edit its file says how it changes now. */
-  async rewordDashboards() {
-    for (const slug of await listDirs(this.paths.projects())) {
-      const file = this.paths.dashboard(slug);
-      if (!await exists(file)) {
-        continue;
-      }
-      const { data, body } = await readLooseMarkdown(file);
-      if (body.includes(OLD_DASHBOARD_LINE)) {
-        await writeMarkdown(file, data, body.replace(OLD_DASHBOARD_LINE, DASHBOARD_LINE));
-      }
-    }
-  }
-  /**
-   * A task sent back before tasks recorded it kept no trace outside the event log. A task still
-   * short of the stage its latest `task.moved` came from is in that rework, and records it.
-   */
-  async recordTaskReturns() {
-    const moves = /* @__PURE__ */ new Map();
-    for (const event of await this.events.readSince(null, Number.POSITIVE_INFINITY)) {
-      const taskId = event.payload["taskId"];
-      if (event.type === "task.moved" && typeof taskId === "string") {
-        moves.set(taskId, event);
-      }
-    }
-    for (const slug of await listDirs(this.paths.projects())) {
-      for (const task2 of await this.listTasks(slug)) {
-        const move = moves.get(task2.id);
-        const from = move?.payload["from"];
-        if (move === void 0 || typeof from !== "string" || task2.returned !== void 0 || task2.completing || task2.status !== "open" && task2.status !== "claimed") {
-          continue;
-        }
-        const back = stageIndex(task2, from);
-        if (back > stageIndex(task2, task2.stage)) {
-          await this.writeTask(slug, {
-            ...task2,
-            returned: { from, by: move.actor, at: move.ts }
-          });
-        }
-      }
-    }
-  }
-  /**
-   * A society channel the board no longer uses leaves the society's list and every member's
-   * subscriptions; its old posts stay on disk. `ops` carried operations signals, which are only
-   * logged now; `decisions` carried proposals' outcomes, which are posts in their threads now, and
-   * requests to the user, which are mentions of the user wherever the question belongs.
-   */
-  async retireSocietyChannel(name) {
-    const doc = await readMarkdown(this.paths.societyFile(), SocietySchema);
-    if (doc.data.channels.includes(name)) {
-      await writeMarkdown(this.paths.societyFile(), { ...doc.data, channels: doc.data.channels.filter((channel) => channel !== name) }, doc.body);
-    }
-    for (const agent2 of await this.listAgents()) {
-      if (agent2.subscriptions.includes(name)) {
-        await this.updateAgent(agent2.name, (a) => ({
-          ...a,
-          subscriptions: a.subscriptions.filter((ref) => ref !== name)
-        }));
-        await this.refreshMember(agent2.name);
-      }
-    }
-  }
-  /**
-   * Asks once opened their threads in general, where closing one posted its summary to every
-   * citizen and woke the steward's heartbeat for it. The society gains the asks channel, and the
-   * front desk follows it.
-   */
-  async openAsksChannel() {
-    const doc = await readMarkdown(this.paths.societyFile(), SocietySchema);
-    if (!doc.data.channels.includes(ASK_CHANNEL)) {
-      await writeMarkdown(this.paths.societyFile(), { ...doc.data, channels: [...doc.data.channels, ASK_CHANNEL] }, doc.body);
-    }
-    await ensureDir(this.paths.societyChannel(ASK_CHANNEL));
-    for (const agent2 of await this.listAgents()) {
-      if (agent2.status !== "active" || agent2.subscriptions.includes(ASK_CHANNEL)) {
-        continue;
-      }
-      if (!(await this.readRole(agent2.role)).wakeTriggers.includes(FRONT_DESK_TRIGGER)) {
-        continue;
-      }
-      await this.updateAgent(agent2.name, (a) => ({
-        ...a,
-        subscriptions: [...a.subscriptions, ASK_CHANNEL]
-      }));
-      await this.refreshMember(agent2.name);
-      await this.events.append("subscription.changed", agent2.name, {
-        channel: ASK_CHANNEL,
-        subscribed: true,
-        aligned: true
-      });
-    }
-  }
-  /** Members that predate `decisions` among the ops channels read proposals without their outcome. */
-  async followDecisions() {
-    if (!(await this.society()).channels.includes("decisions")) {
-      return;
-    }
-    for (const agent2 of await this.listAgents()) {
-      if (agent2.status !== "active" || agent2.subscriptions.includes("decisions")) {
-        continue;
-      }
-      if (!(await this.readRole(agent2.role)).wakeTriggers.includes(OPS_WAKE_TRIGGER)) {
-        continue;
-      }
-      await this.updateAgent(agent2.name, (a) => ({
-        ...a,
-        subscriptions: [...a.subscriptions, "decisions"]
-      }));
-      await this.refreshMember(agent2.name);
-      await this.events.append("subscription.changed", agent2.name, {
-        channel: "decisions",
-        subscribed: true,
-        aligned: true
-      });
-    }
-  }
-  /**
-   * Threads were once a state field on their task. Each becomes a record under the task's project,
-   * on its general channel, closed if its task has ended, and the field leaves the task file.
-   */
-  async recordTaskThreads() {
-    const opened = /* @__PURE__ */ new Map();
-    const closed = /* @__PURE__ */ new Map();
-    for (const event of await this.events.readSince(null, Number.POSITIVE_INFINITY)) {
-      const taskId = event.payload["taskId"];
-      if (typeof taskId !== "string") {
-        continue;
-      }
-      if (event.type === "thread.opened") {
-        opened.set(taskId, event);
-      } else if (event.type === "thread.closed") {
-        closed.set(taskId, event);
-      }
-    }
-    for (const slug of await listDirs(this.paths.projects())) {
-      const threads = this.paths.threads(slug);
-      const summaries = /* @__PURE__ */ new Map();
-      for (const message of await this.readMessagesIn(this.paths.projectChannel(slug, "general"), null)) {
-        if (message.task !== void 0) {
-          summaries.set(message.task, message.body.replace(/^Thread closed[^\n]*\n\n/, ""));
-        }
-      }
-      for (const file of await listFiles(this.paths.tasks(slug))) {
-        const raw = await readMarkdown(path7.join(this.paths.tasks(slug), file), z16.record(z16.string(), z16.unknown()));
-        const legacy = raw.data["thread"];
-        if (legacy === void 0) {
-          continue;
-        }
-        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 open4 = legacy === "open" && !ended;
-          const openedBy = opened.get(task2.id);
-          const closedBy = closed.get(task2.id);
-          await this.writeThread(threads, {
-            id: task2.id,
-            channel: channelRef(slug, "general"),
-            title: task2.title,
-            subject: { kind: "task", id: task2.id },
-            state: open4 ? "open" : "closed",
-            openedBy: openedBy?.actor ?? task2.createdBy,
-            openedAt: openedBy?.ts ?? task2.createdAt,
-            ...open4 ? {} : {
-              closedBy: closedBy?.actor ?? SYSTEM_ACTOR.name,
-              closedAt: closedBy?.ts ?? this.now().toISOString()
-            },
-            body: summaries.get(task2.id) ?? ""
-          });
-        }
-        await this.writeTask(slug, task2);
-      }
-    }
-  }
-  /**
-   * Every channel of a scope was once read in its home conversation, so a member had read each up
-   * to its scope's cursor. Each channel beside general starts from that cursor now, as each takes a
-   * conversation of its own.
-   */
-  async startChannelCursors() {
-    for (const agent2 of await this.listAgents()) {
-      const file = this.paths.agentCursors(agent2.name);
-      if (!await exists(file)) {
-        continue;
-      }
-      const cursors = await readJson(file, CursorsSchema);
-      const scopes = /* @__PURE__ */ new Set([
-        ...Object.keys(cursors.scopes).filter((key) => !key.includes("/")),
-        ...agent2.memberships,
-        SOCIETY_SCOPE
-      ]);
-      const channelsFrom = Object.fromEntries([...scopes].map((scope) => [scope, cursorOf(cursors, scope)]));
-      await writeJson(file, { ...cursors, channelsFrom });
-    }
-  }
-  /**
-   * A project's channels were once read, from the society scope, in the society's home
-   * conversation, so a member had read each up to that cursor. Each project's conversation in the
-   * society scope starts from it now, as each takes a conversation of its own.
-   */
-  async startPlaceCursors() {
-    for (const agent2 of await this.listAgents()) {
-      const file = this.paths.agentCursors(agent2.name);
-      if (!await exists(file)) {
-        continue;
-      }
-      const cursors = await readJson(file, CursorsSchema);
-      await writeJson(file, {
-        ...cursors,
-        placesFrom: { [SOCIETY_SCOPE]: cursorOf(cursors, SOCIETY_SCOPE) }
-      });
-    }
-  }
-  /**
-   * Threads were once read in the scope's single conversation, so a member had read every thread
-   * up to its scope's cursor. Each scope's threads start from that cursor now, as each thread's
-   * conversation takes a cursor of its own.
-   */
-  async startThreadCursors() {
-    for (const agent2 of await this.listAgents()) {
-      const file = this.paths.agentCursors(agent2.name);
-      if (!await exists(file)) {
-        continue;
-      }
-      const cursors = await readJson(file, CursorsSchema);
-      const scopes = /* @__PURE__ */ new Set([
-        ...Object.keys(cursors.scopes).filter((key) => !key.includes("/")),
-        ...agent2.memberships,
-        SOCIETY_SCOPE
-      ]);
-      const threadsFrom = Object.fromEntries([...scopes].map((scope) => [scope, cursorOf(cursors, scope)]));
-      await writeJson(file, { ...cursors, threadsFrom });
-    }
-  }
-  /**
-   * The digest was once called the inbox: each cursor file keyed its cursor `inbox`, and the user
-   * followed every society channel and project general channel to read one. The user takes no
-   * turns, so it follows nothing now.
-   */
-  async renameInboxCursors() {
-    const Legacy = z16.object({ inbox: z16.string().nullable() });
-    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 readFile4(file, "utf8")));
-        if (legacy.success) {
-          await writeJson(file, { digest: legacy.data.inbox });
-        }
-      }
-    }
-    await this.updateAgent(USER_NAME, (user2) => ({ ...user2, subscriptions: [] }));
-    await this.refreshMember(USER_NAME);
+    await writeJson(file, { applied: [...applied, ...pending.map(({ name }) => name)] });
   }
   /** Writes every missing seed charter and aligns the existing ones with their seed. */
   async ensureSeedRoles() {
@@ -4991,7 +4622,7 @@ ${DASHBOARD_LINE}
       if (event.type === "turn.started") {
         const start = TurnStartPayloadSchema.safeParse(event.payload);
         if (start.success)
-          starts.set(start.data.turnId ?? start.data.project, event.ts);
+          starts.set(start.data.turnId, event.ts);
         continue;
       }
       if (event.type !== "turn.completed" && event.type !== "turn.failed") {
@@ -4999,9 +4630,11 @@ ${DASHBOARD_LINE}
       }
       const parsed = TurnHistoryPayloadSchema.safeParse(event.payload);
       if (parsed.success) {
-        const key = parsed.data.turnId ?? parsed.data.project;
-        const startedAt = starts.get(key);
-        starts.delete(key);
+        const { turnId } = parsed.data;
+        const startedAt = turnId === void 0 ? void 0 : starts.get(turnId);
+        if (turnId !== void 0) {
+          starts.delete(turnId);
+        }
         entries.push({
           id: event.id,
           ts: event.ts,
@@ -5236,7 +4869,7 @@ ${DASHBOARD_LINE}
     const starts = [
       ...scopes.flatMap((each) => conversation === void 0 ? [
         cursorOf(cursors, each),
-        threadStart(cursors, each),
+        cursors.digest,
         channelStart(cursors, each),
         placeStart(cursors, each)
       ] : [cursorOf(cursors, each, conversation.part)]),
@@ -5852,11 +5485,12 @@ ${current.body}`);
     const args = VerbInputs.open_thread.parse(input);
     await this.authorize(actor, "open_thread");
     return this.mutex.run(async () => {
-      const opening = await this.threadToOpen(args);
-      if (await this.tryFindThread(opening.id) !== null) {
-        throw new BoardError("INVALID_STATE", `${opening.subject?.kind ?? "thread"} ${opening.id} already has a thread`);
-      }
-      return this.openThreadUnlocked(actor.name, opening);
+      await this.assertChannelOpen(args.channel);
+      return this.openThreadUnlocked(actor.name, {
+        id: this.newId(),
+        channel: args.channel,
+        title: args.title
+      });
     });
   }
   /** Writes a new open thread and its event. Callers hold the mutex and chose where it hangs. */
@@ -5891,28 +5525,13 @@ ${current.body}`);
       subject: { kind: "proposal", id: proposal2.id }
     };
   }
-  /**
-   * The open thread of a proposal being decided. A proposal from before proposals opened their
-   * threads gets one now, opened as its proposer, and a thread closed before the decision opens
-   * again.
-   */
-  async proposalThreadUnlocked(by, proposal2) {
+  /** The open thread of a proposal being decided, which `propose` opened with it. */
+  async proposalThreadUnlocked(proposal2) {
     const found = await this.tryFindThread(proposal2.id);
-    if (found?.thread.state === "open") {
-      return found.thread;
-    }
-    if (found === null) {
-      return this.openThreadUnlocked(proposal2.proposedBy, this.proposalThreadOpening(proposal2));
+    if (found?.thread.state !== "open") {
+      throw new BoardError("INVALID_STATE", `proposal ${proposal2.id} has no open thread`);
     }
-    const { closedBy: _by, closedAt: _at, ...kept } = found.thread;
-    const reopened = await this.writeThread(found.threads, { ...kept, state: "open" });
-    await this.events.append("thread.opened", by, {
-      threadId: proposal2.id,
-      channel: reopened.channel,
-      subject: reopened.subject ?? null,
-      reopened: true
-    });
-    return reopened;
+    return found.thread;
   }
   /** Where a task's thread hangs, what it is called, and what it is about. */
   taskThreadOpening(task2) {
@@ -5924,79 +5543,21 @@ ${current.body}`);
     };
   }
   /**
-   * The open thread of a task in play, for a verb about to post into it. A task from before tasks
-   * opened their threads gets one now, and a thread closed early while its task is in play opens
-   * again; an ended task's thread stays closed.
+   * The open thread of a task in play, for a verb about to post into it, which `createTask` opened
+   * with the task; an ended task's thread closed with it.
    */
-  async taskThreadUnlocked(by, task2) {
+  async taskThreadUnlocked(task2) {
     const found = await this.tryFindThread(task2.id);
     if (found?.thread.state === "open") {
       return found.thread;
     }
-    if (task2.status === "done" || task2.status === "abandoned") {
-      throw new BoardError("INVALID_STATE", `task ${task2.id} is ${task2.status} and its thread closed with it`);
-    }
-    if (found === null) {
-      return this.openThreadUnlocked(by, this.taskThreadOpening(task2));
-    }
-    const { closedBy: _by, closedAt: _at, ...kept } = found.thread;
-    const reopened = await this.writeThread(found.threads, { ...kept, state: "open" });
-    await this.events.append("thread.opened", by, {
-      threadId: task2.id,
-      channel: reopened.channel,
-      subject: reopened.subject ?? null,
-      reopened: true
-    });
-    return reopened;
+    throw new BoardError("INVALID_STATE", task2.status === "done" || task2.status === "abandoned" ? `task ${task2.id} is ${task2.status} and its thread closed with it` : `task ${task2.id} has no open thread`);
   }
   /** Posts what a task verb was told to say into the task's thread, as its author, with the step it recorded. */
   async postTaskNote(author, task2, body, step) {
-    const thread2 = await this.taskThreadUnlocked(author, task2);
+    const thread2 = await this.taskThreadUnlocked(task2);
     return this.appendThreadMessage(author, thread2.id, body, step === void 0 ? {} : { step });
   }
-  /** Where a new thread hangs, what it is called, and what it is about. */
-  async threadToOpen(args) {
-    if (args.task_id !== void 0 && args.proposal_id !== void 0) {
-      throw new BoardError("VALIDATION", "a thread is about one task or one proposal, not both");
-    }
-    if (args.task_id !== void 0) {
-      const { task: task2, project: project2 } = await this.findTask(args.task_id);
-      if (task2.status === "done" || task2.status === "abandoned") {
-        throw new BoardError("INVALID_STATE", `task ${task2.id} is ${task2.status}`);
-      }
-      const channel = args.channel ?? channelRef(project2, task2.channel);
-      if (parseChannelRef(channel).project !== project2) {
-        throw new BoardError("VALIDATION", `a task's thread hangs off a channel of its project, ${project2}`);
-      }
-      await this.assertChannelOpen(channel);
-      return {
-        id: task2.id,
-        channel,
-        title: args.title ?? task2.title,
-        subject: { kind: "task", id: task2.id }
-      };
-    }
-    if (args.proposal_id !== void 0) {
-      const proposal2 = await this.readProposal(args.proposal_id);
-      if (proposal2.status !== "proposed") {
-        throw new BoardError("INVALID_STATE", `proposal ${proposal2.id} is already ${proposal2.status}`);
-      }
-      const channel = args.channel ?? "governance";
-      await this.assertChannelOpen(channel);
-      const described = `${proposal2.kind} proposal: ${describeCharter(proposal2.kind, proposal2.charter)}`;
-      return {
-        id: proposal2.id,
-        channel,
-        title: args.title ?? described.slice(0, 200),
-        subject: { kind: "proposal", id: proposal2.id }
-      };
-    }
-    if (args.channel === void 0 || args.title === void 0) {
-      throw new BoardError("VALIDATION", "a thread needs a task_id, a proposal_id, or a channel and a title");
-    }
-    await this.assertChannelOpen(args.channel);
-    return { id: this.newId(), channel: args.channel, title: args.title };
-  }
   /**
    * Where the board learns which turns are in flight, from the server that hosts them, so it
    * refuses to end a conversation under someone else's turn.
@@ -7130,6 +6691,7 @@ ${rationale}`}`);
         needsUserDecision: parsed.status?.needsUserDecision ?? false,
         error: parsed.error,
         ...parsed.resumeFailed === void 0 ? {} : { resumeFailed: parsed.resumeFailed },
+        ...parsed.transient === true ? { transient: true } : {},
         ...parsed.sessionDropped === true ? { sessionDropped: true } : {}
       });
     });
@@ -7837,15 +7399,9 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       case "archive":
         await this.validateArchive(ArchiveProposalSchema.parse(charter).project);
         return;
-      case "reallocation": {
-        const parsed = ReallocationProposalSchema.safeParse(charter);
-        if (parsed.success) {
-          await this.reallocatedRole(parsed.data);
-        } else {
-          LegacyReallocationSchema.parse(charter);
-        }
+      case "reallocation":
+        await this.reallocatedRole(ReallocationProposalSchema.parse(charter));
         return;
-      }
       default:
         return;
     }
@@ -7905,11 +7461,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
         return { project: input.project, members };
       }
       case "reallocation": {
-        const parsed = ReallocationProposalSchema.safeParse(proposal2.charter);
-        if (!parsed.success) {
-          return void 0;
-        }
-        const { next, changed } = await this.reallocatedRole(parsed.data);
+        const { next, changed } = await this.reallocatedRole(ReallocationProposalSchema.parse(proposal2.charter));
         await this.writeRoleUnlocked(by, next, meta);
         return { role: next.name, changed };
       }
@@ -7919,8 +7471,8 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
   }
   /**
    * 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.
+   * it: the folder the board took from its proposer's home. 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);
@@ -7928,16 +7480,12 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     const replaced = await exists(file);
     const taken = proposal2.skillFiles;
     const staged = path7.join(this.paths.proposalFiles(proposal2.id), "SKILL.md");
-    if (skill2.body === void 0 && (taken === void 0 || !await exists(staged))) {
+    if (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 cp(this.paths.proposalFiles(proposal2.id), dir, { recursive: true });
+    const { body } = await readLooseMarkdown(file);
     await writeMarkdown(file, {
       name: skill2.name,
       description: skill2.summary,
@@ -7945,7 +7493,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
         proposedBy: proposal2.proposedBy,
         promotedBy: by,
         promotedAt: this.now().toISOString(),
-        ...taken === void 0 ? {} : { commit: taken.commit }
+        commit: taken.commit
       }
     }, body);
     await this.events.append("skill.promoted", by, {
@@ -7953,7 +7501,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       summary: skill2.summary,
       proposedBy: proposal2.proposedBy,
       replaced,
-      ...taken === void 0 ? {} : { files: taken.files.length },
+      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.`);
@@ -8642,6 +8190,7 @@ ${charter.purpose}
       await this.validateProvision(filed.kind, filed.charter);
     }
     this.assertNoTurnCut(actor, `proposal ${proposalId} cannot be decided`, (turn2) => turn2.thread === proposalId);
+    const thread2 = await this.proposalThreadUnlocked(filed);
     if (outcome === "approved" && filed.kind === "archive") {
       await this.assertProjectQuiet(actor, ArchiveProposalSchema.parse(filed.charter).project);
     }
@@ -8683,7 +8232,6 @@ ${charter.purpose}
     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);
@@ -9182,13 +8730,11 @@ task.command("list <project>").description("List a project's tasks with their cu
   }).join("\n"));
 });
 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) => {
+thread.command("open").description("Open a thread on a channel with a title; a task's or a proposal's opens with it").requiredOption("--channel <ref>", "the channel it hangs off").requiredOption("--title <text>", "the thread's title").option("--as <agent>", "act as this agent instead of the user").action(async (opts) => {
   const board = await open3();
   const opened = await board.openThread(await actorFor(board, opts.as), {
-    ...taskId === void 0 ? {} : { task_id: taskId },
-    ...opts.proposal === void 0 ? {} : { proposal_id: opts.proposal },
-    ...opts.channel === void 0 ? {} : { channel: opts.channel },
-    ...opts.title === void 0 ? {} : { title: opts.title }
+    channel: opts.channel,
+    title: opts.title
   });
   print(opened, () => `Thread ${opened.id} opened on ${opened.channel}: ${opened.title}`);
 });