@kubitnodes/stellaris 0.3.24 → 0.3.26

package/dist/server/index.js

@@ -768,7 +768,6 @@ var ReallocationProposalSchema = z5.object({
   changes: RoleChangesSchema,
   description: z5.string().min(1)
 });
-var LegacyReallocationSchema = z5.object({ description: z5.string().min(1) });
 function applyRoleChanges(role, changes) {
   return {
     ...role,
@@ -813,8 +812,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,
@@ -891,14 +889,10 @@ function describeCharter(kind, charter) {
     }
     case "reallocation": {
       const parsed = ReallocationProposalSchema.safeParse(charter);
-      if (parsed.success) {
-        const { role, changes, description } = parsed.data;
-        return `reallocation of role ${role} (${describeRoleChanges(changes)}): ${description}`;
-      }
-      const legacy = LegacyReallocationSchema.safeParse(charter);
-      if (!legacy.success)
+      if (!parsed.success)
         break;
-      return `reallocation: ${legacy.data.description}`;
+      const { role, changes, description } = parsed.data;
+      return `reallocation of role ${role} (${describeRoleChanges(changes)}): ${description}`;
     }
     case "skill": {
       const parsed = SkillProposalSchema.safeParse(charter);
@@ -1109,12 +1103,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({
@@ -1628,6 +1620,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(),
@@ -1953,6 +1951,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. */
@@ -2027,7 +2027,8 @@ 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 = [
@@ -2051,8 +2052,18 @@ 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);
+function signalWakes(signal) {
+  return signal.wakes ?? WAKING.has(signal.kind);
+}
 
 // packages/shared/dist/metrics.js
 import { z as z12 } from "zod";
@@ -2246,7 +2257,7 @@ var RunnerConfigSchema = z13.object({
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.3.24";
+var STELLARIS_VERSION = "0.3.26";
 
 // packages/shared/dist/mentions.js
 import { parse, postprocess, preprocess } from "micromark";
@@ -3577,7 +3588,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;
@@ -3592,6 +3603,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
@@ -3626,6 +3644,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;
@@ -3696,17 +3717,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. */
@@ -3715,7 +3735,6 @@ var CursorsSchema = z16.object({
 var NO_CURSORS = {
   digest: null,
   scopes: {},
-  threadsFrom: {},
   channelsFrom: {},
   placesFrom: {}
 };
@@ -3739,10 +3758,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;
@@ -3754,7 +3769,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;
@@ -3775,7 +3790,7 @@ function skillFolderOf(proposal) {
     return null;
   }
   const parsed = SkillProposalSchema.safeParse(proposal.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;
@@ -3790,28 +3805,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"];
@@ -3831,9 +3824,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("#")) ?? "";
 }
@@ -3986,390 +3979,22 @@ var Board = class _Board {
     return board2;
   }
   /**
-   * 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 knowledge = KnowledgeEventSchema.safeParse(verb.payload);
-      const id = UlidSchema.safeParse(event.payload["id"]);
-      if (!knowledge.success || !id.success || (event.payload["thread"] ?? null) !== null || event.payload["channel"] !== channelRef(knowledge.data.project, "general")) {
-        continue;
-      }
-      const { topic, project, replaced } = knowledge.data;
-      const file = this.paths.messageFile(this.paths.channelDir(channelRef(project, "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
-      };
-      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 });
-      }
-    }
-  }
-  /** 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 task of await this.listTasks(slug)) {
-        const move = moves.get(task.id);
-        const from = move?.payload["from"];
-        if (move === void 0 || typeof from !== "string" || task.returned !== void 0 || task.completing || task.status !== "open" && task.status !== "claimed") {
-          continue;
-        }
-        const back = stageIndex(task, from);
-        if (back > stageIndex(task, task.stage)) {
-          await this.writeTask(slug, {
-            ...task,
-            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 agent of await this.listAgents()) {
-      if (agent.subscriptions.includes(name)) {
-        await this.updateAgent(agent.name, (a) => ({
-          ...a,
-          subscriptions: a.subscriptions.filter((ref) => ref !== name)
-        }));
-        await this.refreshMember(agent.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 agent of await this.listAgents()) {
-      if (agent.status !== "active" || agent.subscriptions.includes(ASK_CHANNEL)) {
-        continue;
-      }
-      if (!(await this.readRole(agent.role)).wakeTriggers.includes(FRONT_DESK_TRIGGER)) {
-        continue;
-      }
-      await this.updateAgent(agent.name, (a) => ({
-        ...a,
-        subscriptions: [...a.subscriptions, ASK_CHANNEL]
-      }));
-      await this.refreshMember(agent.name);
-      await this.events.append("subscription.changed", agent.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 agent of await this.listAgents()) {
-      if (agent.status !== "active" || agent.subscriptions.includes("decisions")) {
-        continue;
-      }
-      if (!(await this.readRole(agent.role)).wakeTriggers.includes(OPS_WAKE_TRIGGER)) {
-        continue;
-      }
-      await this.updateAgent(agent.name, (a) => ({
-        ...a,
-        subscriptions: [...a.subscriptions, "decisions"]
-      }));
-      await this.refreshMember(agent.name);
-      await this.events.append("subscription.changed", agent.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 task = { ...TaskFrontmatterSchema.parse(raw.data), body: raw.body };
-        if ((legacy === "open" || legacy === "closed") && !await exists(this.paths.threadFile(threads, task.id))) {
-          const ended = task.status === "done" || task.status === "abandoned";
-          const open3 = legacy === "open" && !ended;
-          const openedBy = opened.get(task.id);
-          const closedBy = closed.get(task.id);
-          await this.writeThread(threads, {
-            id: task.id,
-            channel: channelRef(slug, "general"),
-            title: task.title,
-            subject: { kind: "task", id: task.id },
-            state: open3 ? "open" : "closed",
-            openedBy: openedBy?.actor ?? task.createdBy,
-            openedAt: openedBy?.ts ?? task.createdAt,
-            ...open3 ? {} : {
-              closedBy: closedBy?.actor ?? SYSTEM_ACTOR.name,
-              closedAt: closedBy?.ts ?? this.now().toISOString()
-            },
-            body: summaries.get(task.id) ?? ""
-          });
-        }
-        await this.writeTask(slug, task);
-      }
-    }
-  }
-  /**
-   * 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 agent of await this.listAgents()) {
-      const file = this.paths.agentCursors(agent.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("/")),
-        ...agent.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 agent of await this.listAgents()) {
-      const file = this.paths.agentCursors(agent.name);
-      if (!await exists(file)) {
-        continue;
-      }
-      const cursors = await readJson(file, CursorsSchema);
-      await writeJson(file, {
-        ...cursors,
-        placesFrom: { [SOCIETY_SCOPE]: cursorOf(cursors, SOCIETY_SCOPE) }
-      });
+    for (const { apply } of pending) {
+      await apply();
     }
-  }
-  /**
-   * 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 agent of await this.listAgents()) {
-      const file = this.paths.agentCursors(agent.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("/")),
-        ...agent.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 agent of await this.listAgents()) {
-      const file = this.paths.agentCursors(agent.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, (user) => ({ ...user, 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() {
@@ -5173,7 +4798,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") {
@@ -5181,9 +4806,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,
@@ -5418,7 +5045,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)]),
@@ -6034,11 +5661,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. */
@@ -6073,28 +5701,13 @@ ${current.body}`);
       subject: { kind: "proposal", id: proposal.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, proposal) {
+  /** The open thread of a proposal being decided, which `propose` opened with it. */
+  async proposalThreadUnlocked(proposal) {
     const found = await this.tryFindThread(proposal.id);
-    if (found?.thread.state === "open") {
-      return found.thread;
-    }
-    if (found === null) {
-      return this.openThreadUnlocked(proposal.proposedBy, this.proposalThreadOpening(proposal));
+    if (found?.thread.state !== "open") {
+      throw new BoardError("INVALID_STATE", `proposal ${proposal.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: proposal.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(task) {
@@ -6106,79 +5719,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, task) {
+  async taskThreadUnlocked(task) {
     const found = await this.tryFindThread(task.id);
     if (found?.thread.state === "open") {
       return found.thread;
     }
-    if (task.status === "done" || task.status === "abandoned") {
-      throw new BoardError("INVALID_STATE", `task ${task.id} is ${task.status} and its thread closed with it`);
-    }
-    if (found === null) {
-      return this.openThreadUnlocked(by, this.taskThreadOpening(task));
-    }
-    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: task.id,
-      channel: reopened.channel,
-      subject: reopened.subject ?? null,
-      reopened: true
-    });
-    return reopened;
+    throw new BoardError("INVALID_STATE", task.status === "done" || task.status === "abandoned" ? `task ${task.id} is ${task.status} and its thread closed with it` : `task ${task.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, task, body, step) {
-    const thread = await this.taskThreadUnlocked(author, task);
+    const thread = await this.taskThreadUnlocked(task);
     return this.appendThreadMessage(author, thread.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, project } = await this.findTask(args.task_id);
-      if (task.status === "done" || task.status === "abandoned") {
-        throw new BoardError("INVALID_STATE", `task ${task.id} is ${task.status}`);
-      }
-      const channel = args.channel ?? channelRef(project, task.channel);
-      if (parseChannelRef(channel).project !== project) {
-        throw new BoardError("VALIDATION", `a task's thread hangs off a channel of its project, ${project}`);
-      }
-      await this.assertChannelOpen(channel);
-      return {
-        id: task.id,
-        channel,
-        title: args.title ?? task.title,
-        subject: { kind: "task", id: task.id }
-      };
-    }
-    if (args.proposal_id !== void 0) {
-      const proposal = await this.readProposal(args.proposal_id);
-      if (proposal.status !== "proposed") {
-        throw new BoardError("INVALID_STATE", `proposal ${proposal.id} is already ${proposal.status}`);
-      }
-      const channel = args.channel ?? "governance";
-      await this.assertChannelOpen(channel);
-      const described = `${proposal.kind} proposal: ${describeCharter(proposal.kind, proposal.charter)}`;
-      return {
-        id: proposal.id,
-        channel,
-        title: args.title ?? described.slice(0, 200),
-        subject: { kind: "proposal", id: proposal.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.
@@ -7312,6 +6867,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 } : {}
       });
     });
@@ -8019,15 +7575,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;
     }
@@ -8087,11 +7637,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(proposal.charter);
-        if (!parsed.success) {
-          return void 0;
-        }
-        const { next, changed } = await this.reallocatedRole(parsed.data);
+        const { next, changed } = await this.reallocatedRole(ReallocationProposalSchema.parse(proposal.charter));
         await this.writeRoleUnlocked(by, next, meta);
         return { role: next.name, changed };
       }
@@ -8101,8 +7647,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, proposal, skill, meta) {
     const dir = this.paths.societySkill(skill.name);
@@ -8110,16 +7656,12 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     const replaced = await exists(file);
     const taken = proposal.skillFiles;
     const staged = path7.join(this.paths.proposalFiles(proposal.id), "SKILL.md");
-    if (skill.body === void 0 && (taken === void 0 || !await exists(staged))) {
+    if (taken === void 0 || !await exists(staged)) {
       throw new BoardError("INVALID_STATE", `proposal ${proposal.id} holds no skill files`);
     }
     await rm2(dir, { recursive: true, force: true });
-    if (skill.body === void 0) {
-      await cp(this.paths.proposalFiles(proposal.id), dir, { recursive: true });
-    } else {
-      await ensureDir(dir);
-    }
-    const body = skill.body ?? (await readLooseMarkdown(file)).body;
+    await cp(this.paths.proposalFiles(proposal.id), dir, { recursive: true });
+    const { body } = await readLooseMarkdown(file);
     await writeMarkdown(file, {
       name: skill.name,
       description: skill.summary,
@@ -8127,7 +7669,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
         proposedBy: proposal.proposedBy,
         promotedBy: by,
         promotedAt: this.now().toISOString(),
-        ...taken === void 0 ? {} : { commit: taken.commit }
+        commit: taken.commit
       }
     }, body);
     await this.events.append("skill.promoted", by, {
@@ -8135,7 +7677,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       summary: skill.summary,
       proposedBy: proposal.proposedBy,
       replaced,
-      ...taken === void 0 ? {} : { files: taken.files.length },
+      files: taken.files.length,
       ...meta
     });
     await this.appendMessage(SYSTEM_ACTOR.name, "general", `Skill ${skill.name} ${replaced ? "updated in" : "promoted to"} the society: ${sentence(skill.summary)}. Every citizen's skills index now lists it.`);
@@ -8824,6 +8366,7 @@ ${charter.purpose}
       await this.validateProvision(filed.kind, filed.charter);
     }
     this.assertNoTurnCut(actor, `proposal ${proposalId} cannot be decided`, (turn) => turn.thread === proposalId);
+    const thread = await this.proposalThreadUnlocked(filed);
     if (outcome === "approved" && filed.kind === "archive") {
       await this.assertProjectQuiet(actor, ArchiveProposalSchema.parse(filed.charter).project);
     }
@@ -8865,7 +8408,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 thread = await this.proposalThreadUnlocked(actor.name, proposal);
     const post = `${verdict}: ${describeCharter(proposal.kind, proposal.charter)}.${why}${result}`;
     await this.appendThreadMessage(actor.name, thread.id, actor.name === SYSTEM_ACTOR.name ? withoutMentions(post) : post, { step: { action: outcome } });
     await this.endThreadOf(proposalId, actor.name, outcome);
@@ -9085,12 +8627,14 @@ var DEFAULT_TIMINGS = Object.freeze({
   leaseSweepMs: 6e4,
   opsIntervalMs: 5 * 6e4,
   signalRepeatMs: 6 * 36e5,
+  signalWakeMs: 24 * 36e5,
   costReportMs: 36e5,
   staleThreadMs: 24 * 36e5,
   idleMemberMs: 3 * 24 * 36e5,
   homeConflictMs: 24 * 36e5,
   scaleCooldownMs: 36e5,
-  reflectionMs: 24 * 36e5
+  reflectionMs: 24 * 36e5,
+  transientRetryMs: [6e4, 3 * 6e4, 10 * 6e4]
 });
 var SchedulerTimingsSchema = z17.object({
   pollMs: z17.number().positive(),
@@ -9101,18 +8645,20 @@ var SchedulerTimingsSchema = z17.object({
   leaseSweepMs: z17.number().positive(),
   opsIntervalMs: z17.number().positive(),
   signalRepeatMs: z17.number().positive(),
+  signalWakeMs: z17.number().positive(),
   costReportMs: z17.number().positive(),
   staleThreadMs: z17.number().positive(),
   idleMemberMs: z17.number().positive(),
   homeConflictMs: z17.number().positive(),
   scaleCooldownMs: z17.number().positive(),
-  reflectionMs: z17.number().positive()
+  reflectionMs: z17.number().positive(),
+  transientRetryMs: z17.array(z17.number().positive())
 }).partial();
 function parseTimings(input) {
   const parsed = SchedulerTimingsSchema.parse(input);
   const overrides = {};
   for (const [key, value] of Object.entries(parsed)) {
-    if (typeof value === "number") {
+    if (value !== void 0) {
       Object.assign(overrides, { [key]: value });
     }
   }
@@ -9136,6 +8682,11 @@ var StateSchema = z17.object({
   /** Queued dispatches survive a restart; the cursor has already moved past the events that made them. */
   pending: z17.record(z17.string(), PendingSchema).default({}),
   opsReported: z17.record(z17.string(), z17.string()).default({}),
+  /**
+   * When each condition of a waking kind that still holds last woke the readers of signals, and
+   * the level it woke at for the kinds that have one (`wakeLevel`); forgotten with the condition.
+   */
+  opsWoken: z17.record(z17.string(), z17.object({ at: z17.string(), level: z17.number().optional() })).default({}),
   releaseCounts: z17.record(z17.string(), z17.number().int().nonnegative()).default({}),
   lastOps: z17.string().nullable().default(null),
   lastScaled: z17.record(z17.string(), z17.string()).default({}),
@@ -9160,6 +8711,22 @@ var SILENT_LOG = { info() {
 }, error() {
 } };
 var WAKING_SIGNALS = new Set(WAKING_SIGNAL_KINDS);
+var DAY_MS = 24 * 36e5;
+var IDLE_WAKE_STEPS_MS = [7 * DAY_MS, 14 * DAY_MS, 30 * DAY_MS];
+function wakeLevel(signal) {
+  switch (signal.kind) {
+    case "idle_member":
+      return IDLE_WAKE_STEPS_MS.filter((step) => signal.value >= step).length;
+    case "churn":
+      return signal.value;
+    default:
+      return void 0;
+  }
+}
+function wokenAt(signal, now) {
+  const level = wakeLevel(signal);
+  return { at: iso(now), ...level === void 0 ? {} : { level } };
+}
 var HEARTBEAT_TRIGGER = "heartbeat";
 var OPS_TRIGGER = "ops_event";
 var USER_POST_TRIGGER = "user_post";
@@ -9216,6 +8783,8 @@ var Scheduler = class {
   sweeping = /* @__PURE__ */ new Set();
   /** Crons whose fire's turn is running; a cron's next time passes while one is. */
   cronsInFlight = /* @__PURE__ */ new Set();
+  /** Turns in a row the model service turned away, by session key, which `retryRefused` counts. */
+  refused = /* @__PURE__ */ new Map();
   state = StateSchema.parse({
     cursor: null,
     lastHeartbeat: {}
@@ -9428,10 +8997,6 @@ var Scheduler = class {
           await this.wakeCreator(taskId, project, creator, event.actor, now);
         }
         await this.wakeDependents(taskId, event.actor, now);
-        const threaded = await this.board.readThread(taskId).then(() => true, () => false);
-        if (!threaded) {
-          this.sweep({ kind: "thread", id: taskId });
-        }
         return;
       }
       case "thread.closed": {
@@ -9591,7 +9156,7 @@ var Scheduler = class {
       }
       case "ops.signal": {
         const parsed = OpsSignalSchema.safeParse(payload);
-        if (!parsed.success || !WAKING_SIGNALS.has(parsed.data.kind)) {
+        if (!parsed.success || !signalWakes(parsed.data)) {
           return;
         }
         await this.wakeSignalReaders(parsed.data, event.actor, now);
@@ -10302,25 +9867,56 @@ var Scheduler = class {
   // ---------------------------------------------------------------------------------------------
   // Operations: signals from state, the scaling rule, and the spend report
   // ---------------------------------------------------------------------------------------------
+  /**
+   * Logs each condition when it is new and again every `signalRepeatMs` while it holds, and marks
+   * each log with whether it wakes the readers of signals (`wakesNow`), so a repeat only logs.
+   */
   async runOperations(now) {
     const signals = await this.collectSignals(now);
     const current = new Set(signals.map((signal) => signal.key));
-    for (const key of Object.keys(this.state.opsReported)) {
-      if (!current.has(key)) {
-        delete this.state.opsReported[key];
+    for (const record of [this.state.opsReported, this.state.opsWoken]) {
+      for (const key of Object.keys(record)) {
+        if (!current.has(key)) {
+          delete record[key];
+        }
       }
     }
     for (const signal of signals) {
       const reported = this.state.opsReported[signal.key];
-      if (reported !== void 0 && now - Date.parse(reported) < this.timings.signalRepeatMs) {
+      const wakes = this.wakesNow(signal, reported !== void 0, now);
+      if (!wakes && reported !== void 0 && now - Date.parse(reported) < this.timings.signalRepeatMs) {
         continue;
       }
-      await this.board.publishSignal(signal);
+      await this.board.publishSignal({ ...signal, wakes });
       this.state.opsReported[signal.key] = iso(now);
+      if (wakes) {
+        this.state.opsWoken[signal.key] = wokenAt(signal, now);
+      }
     }
     await this.scaleRoles(now);
     await this.reportCost(now);
   }
+  /**
+   * Whether a condition wakes the readers of signals at this pass, which only a waking kind does:
+   * when it is new; for an idle member or churn, when it has risen past the level it last woke at
+   * (`wakeLevel`); for the other kinds, once its last wake is `signalWakeMs` old. Checked on every
+   * pass, so a step wakes when it is crossed, between repeats.
+   */
+  wakesNow(signal, held, now) {
+    if (!WAKING_SIGNALS.has(signal.kind)) {
+      return false;
+    }
+    const last = this.state.opsWoken[signal.key];
+    if (last === void 0) {
+      if (held) {
+        this.state.opsWoken[signal.key] = wokenAt(signal, now);
+        return false;
+      }
+      return true;
+    }
+    const level = wakeLevel(signal);
+    return level === void 0 ? now - Date.parse(last.at) >= this.timings.signalWakeMs : level > (last.level ?? 0);
+  }
   /** Every operations condition that holds right now, from counters and timers only. */
   async collectSignals(now) {
     const signals = [];
@@ -10637,6 +10233,7 @@ var Scheduler = class {
             exitReason: record.exitReason,
             costUsd: record.costUsd
           }, "turn finished");
+          await this.retryRefused(key, { ...item, dispatch }, record);
         } catch (error) {
           this.log.error({ agent: dispatch.agent, project: dispatch.project, error: String(error) }, "turn crashed");
         } finally {
@@ -10655,6 +10252,48 @@ var Scheduler = class {
       }
     }
   }
+  /**
+   * A turn the model service turned away for now, overloaded or failing on its side, is sent again:
+   * the same wake in the same conversation, after the next delay of `transientRetryMs`, with every
+   * check a queued wake gets at dispatch. A wake already queued there, as a heartbeat's or a new
+   * post's, runs the conversation instead. Once the delays are spent the heartbeat takes over, and
+   * a `turn_refused` signal, which wakes nobody, says so. A turn that ends any other way ends the run.
+   */
+  async retryRefused(key, item, record) {
+    if (record.transient !== true || record.exitReason !== "error") {
+      this.refused.delete(key);
+      return;
+    }
+    const refused = (this.refused.get(key) ?? 0) + 1;
+    this.refused.set(key, refused);
+    const { dispatch } = item;
+    const delay = this.timings.transientRetryMs[refused - 1];
+    if (delay !== void 0) {
+      if (this.pending.has(key)) {
+        return;
+      }
+      const { steeredThrough: _steered, ...retry } = item;
+      this.pending.set(key, { ...retry, readyAt: this.now().getTime() + delay });
+      this.log.info({ agent: dispatch.agent, project: dispatch.project, refused, delayMs: delay }, "the model service turned the turn away, sending its wake again");
+      return;
+    }
+    if (refused !== this.timings.transientRetryMs.length + 1) {
+      return;
+    }
+    const agent = await this.tryReadAgent(dispatch.agent);
+    const where = dispatch.thread !== void 0 ? `thread ${dispatch.thread.id}` : dispatch.channel !== void 0 ? `channel ${dispatch.channel}` : dispatch.place !== void 0 ? `project ${dispatch.place}'s channels` : "its home";
+    await this.board.publishSignal({
+      kind: "turn_refused",
+      key: `turn_refused:${key}`,
+      summary: `${dispatch.agent}'s turns in ${where} were turned away by the model service ${refused} times in a row${record.model === null ? "" : ` on ${record.model}`}, the last with "${record.error ?? "no error"}"; its heartbeat takes over`,
+      value: refused,
+      threshold: refused,
+      agent: dispatch.agent,
+      ...agent === null ? {} : { role: agent.role },
+      ...dispatch.project === SOCIETY_SCOPE ? {} : { project: dispatch.project },
+      ...dispatch.thread?.task === true ? { taskId: dispatch.thread.id } : {}
+    });
+  }
   /**
    * Whether a ready turn waits for another of its citizen's turns that must run alone: its
    * onboarding in the project, queued or running, which comes before any other work of its there;
@@ -10773,7 +10412,7 @@ var GOVERNANCE = [
   '  - retirement: {"agent", "reason"}',
   '  - archive: {"project", "reason"}: approval archives the project: its members leave, its open threads close, and nothing more is posted, filed, or joined there, while its files and history stay; refused while a task there is in play',
   `  - reallocation: {"role", "changes": {"maxReplicas"?, "backlogThreshold"?, "wakeTriggers"?, "verbs"?}, "description"}: approval applies the changes to the existing role, each the field's new value and verbs and wakeTriggers whole lists, for its members from their next turn; refused for a role that does not exist or that has those values already. Only the user decides one that changes verbs or maxReplicas`,
-  '  - skill: {"name", "summary"}: the folder skills/<name>/ in your home, SKILL.md and every file beside it, which the board takes as it stands when this turn ends into society/proposals/<id>/, where whoever decides reads it; a proposal whose folder has no SKILL.md then is rejected by the board. Approval publishes it under society/skills/<name>/, where every citizen\'s skills index lists it until the steward or the user removes it with `remove_skill`; ask the steward to remove one that is wrong or superseded. Once yours is approved, delete skills/<name>/ from your home and report memoryUpdated: the board leaves your copy there, and your index would list it beside the published one and follow it as it drifts from what was reviewed. To revise a published skill, copy its folder home, edit it, and propose it again. A proposal from before folders carries "body", its SKILL.md text alone',
+  '  - skill: {"name", "summary"}: the folder skills/<name>/ in your home, SKILL.md and every file beside it, which the board takes as it stands when this turn ends into society/proposals/<id>/, where whoever decides reads it; a proposal whose folder has no SKILL.md then is rejected by the board. Approval publishes it under society/skills/<name>/, where every citizen\'s skills index lists it until the steward or the user removes it with `remove_skill`; ask the steward to remove one that is wrong or superseded. Once yours is approved, delete skills/<name>/ from your home and report memoryUpdated: the board leaves your copy there, and your index would list it beside the published one and follow it as it drifts from what was reviewed. To revise a published skill, copy its folder home, edit it, and propose it again.',
   "- Projects and membership: a project is a lasting area of work, not one request; `create_project` opens one with its general channel (front desk and user), and `configure_project` sets its completion effect, its display name, or its default branch, never its slug (user, steward, concierge). A workstream within a project or the society, such as a release, gets a channel of its own: `create_channel` opens it, which its opener follows, and announces it in the place's general, where members subscribe when it concerns them, `create_task` with `channel` files the workstream's tasks there, and `archive_channel` ends it once none of its tasks is in play, leaving its history readable (user, steward, concierge; others propose a channel). A project whose work is finished or has moved to another project is archived by proposal, once no task there is in play. `join_project` and `leave_project` move yourself, or another citizen when you are the concierge, the steward, or the user; joining gives the pair a worktree and an onboarding turn. A society role, one that keeps watch over the whole society as the concierge and the steward do, is never in a project: it moves others, never itself.",
   "- Prefer scaling an existing role over inventing one, with a reallocation of its replicas, backlog threshold, wakes, or verbs; a new role is justified by work a project needs that no existing role covers. A role that needs a tool the board lacks is an engineering task, not a hiring request.",
   "- Operations signals are counters and timers the board logs, listed in the prompt of a role that reads them: stages waiting for a holder, backlog per role, stages waiting on a role nobody fills, churn, stale threads, idle members, missing capabilities, replicas added, spend. They are not posts in any channel; interpreting them is your judgment."
@@ -11083,7 +10722,7 @@ function buildTurnPrompt(input) {
     if (signals.length === 0) {
       lines.push("None since your last turn here.");
     } else {
-      lines.push("Counters and timers the board logged since your last turn here, oldest first. A condition that persists is logged again every few hours; one that clears is not logged.", "");
+      lines.push("Counters and timers the board logged since your last turn here, each condition once at its latest log, oldest first, with the hourly spend reports summed into one line. A condition that persists is logged again every few hours; one that clears is not logged.", "");
       for (const { ts, signal } of signals) {
         lines.push(signalLine(ts, signal));
       }
@@ -11147,6 +10786,43 @@ function stuckNotice(stuck) {
   return `${stuck.agent}'s worktree for this task holds commits that \`${stuck.branch}\` lacks and that the runner cannot fast-forward it to, because they no longer build on its tip or another worktree's commits build on it too: ${commits}. Until someone puts them on the branch, it lacks them, and so does what lands from it; any worktree of the project's clone can cherry-pick or merge them by id.`;
 }
 var MAX_SIGNALS = 30;
+var SIGNAL_READ = 500;
+var REPORT_TURNS = /^(\d+) turn\(s\) completed /;
+function sumSpend(records, partial) {
+  const reports = records.filter((record) => record.signal.kind === "turn_cost");
+  const last = reports.at(-1);
+  if (last === void 0 || reports.length === 1 && !partial) {
+    return [...records];
+  }
+  let cost = 0;
+  let turns2 = 0;
+  let dearest = last;
+  for (const report of reports) {
+    cost += report.signal.value;
+    const counted = REPORT_TURNS.exec(report.signal.summary)?.[1];
+    turns2 = turns2 === null || counted === void 0 ? null : turns2 + Number(counted);
+    if (report.signal.value > dearest.signal.value) {
+      dearest = report;
+    }
+  }
+  const first = reports[0] ?? last;
+  const one = reports.length === 1;
+  const summary = [
+    `${turns2 === null ? "turns" : `${turns2} turn(s)`} completed for $${cost.toFixed(2)} in ${reports.length} hourly report(s) logged ${one ? `at ${last.ts}` : `from ${first.ts} to ${last.ts}`}`,
+    ...one ? [] : [`the dearest, logged at ${dearest.ts}, was $${dearest.signal.value.toFixed(2)}`],
+    ...partial ? [`the read holds the newest ${SIGNAL_READ} signals, so these are lower bounds`] : []
+  ].join("; ");
+  const summed = { ...last, signal: { ...last.signal, summary, value: cost } };
+  return records.flatMap((record) => record === last ? [summed] : record.signal.kind === "turn_cost" ? [] : [record]);
+}
+function latestPerKey(records) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    latest.delete(record.signal.key);
+    latest.set(record.signal.key, record);
+  }
+  return [...latest.values()];
+}
 var TurnHost = class {
   board;
   mcpUrl;
@@ -11284,7 +10960,7 @@ var TurnHost = class {
       dir: `${PATH_TOKENS.board}/projects/${dispatch.project}/knowledge`,
       topics: await this.board.listKnowledge(dispatch.project)
     };
-    const signals = part === void 0 && charter.wakeTriggers.includes(OPS_TRIGGER2) ? (await this.board.listSignals(500)).filter((record2) => wakeScope(agent, record2.signal.project ?? null) === dispatch.project && (lastTurn === null || record2.ts > lastTurn.startedAt)).slice(-MAX_SIGNALS) : null;
+    const signals = part === void 0 && charter.wakeTriggers.includes(OPS_TRIGGER2) ? await this.signalsSince(agent, dispatch.project, lastTurn) : null;
     const waiting = task !== null && task.status === "open" && !task.completing && mayHoldStage(actor, task) ? [task] : [];
     const threads = /* @__PURE__ */ new Map();
     for (const id of new Set(messages.flatMap((message) => message.thread ?? []))) {
@@ -11559,6 +11235,7 @@ var TurnHost = class {
       ...outcome.work === null ? {} : { work: outcome.work },
       ...outcome.exitReason === "stopped" ? { stoppedBy: turn.stopRequestedBy ?? USER_NAME } : {},
       ...outcome.resumeFailed === void 0 ? {} : { resumeFailed: outcome.resumeFailed },
+      ...outcome.transient === true ? { transient: true } : {},
       ...resumeRetries === void 0 ? {} : { resumeRetries },
       ...dropSession ? { sessionDropped: true } : {}
     };
@@ -11738,6 +11415,17 @@ var TurnHost = class {
     this.residentTokens.set(slot, token);
     return token;
   }
+  /**
+   * The signals a reader's prompt lists: those logged for its scope since its last turn there,
+   * the spend reports summed, then each condition once at its latest log, the newest kept.
+   */
+  async signalsSince(agent, scope, lastTurn) {
+    const read2 = await this.board.listSignals(SIGNAL_READ + 1);
+    const past = read2.length > SIGNAL_READ ? read2[0] : void 0;
+    const partial = past !== void 0 && (lastTurn === null || past.ts > lastTurn.startedAt);
+    const since = read2.slice(-SIGNAL_READ).filter((record) => wakeScope(agent, record.signal.project ?? null) === scope && (lastTurn === null || record.ts > lastTurn.startedAt));
+    return latestPerKey(sumSpend(since, partial)).slice(-MAX_SIGNALS);
+  }
   /**
    * Where a conversation works: a task's on its branch, which its stage's holder has to itself,
    * any other thread's, a channel's, and a project's channels' seen from the society scope in a
@@ -12625,6 +12313,8 @@ import pino from "pino";
 // packages/board-mcp/dist/index.js
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+var MAX_TOOL_INPUT_ELEMENTS = 1e3;
+var MAX_REQUEST_BODY_SIZE = 1024 * 1024;
 var BOARD_TOOLS = VERB_NAMES.map((name) => ({
   name,
   description: VERB_DESCRIPTIONS[name],
@@ -12647,7 +12337,7 @@ function describeError(error) {
   return String(error);
 }
 async function createBoardMcpServer(board2, actor, version) {
-  const server2 = new McpServer({ name: "stellaris-board", version });
+  const server2 = new McpServer({ name: "stellaris-board", version }, { maxToolInputElements: MAX_TOOL_INPUT_ELEMENTS });
   const charter = await board2.readRole(actor.role);
   for (const tool of toolsForRole(charter)) {
     server2.registerTool(tool.name, { description: tool.description, inputSchema: tool.inputSchema }, async (args) => {
@@ -12668,7 +12358,10 @@ async function createBoardMcpServer(board2, actor, version) {
 }
 async function handleMcpRequest(board2, actor, request, version) {
   const server2 = await createBoardMcpServer(board2, actor, version);
-  const transport = new WebStandardStreamableHTTPServerTransport({ enableJsonResponse: true });
+  const transport = new WebStandardStreamableHTTPServerTransport({
+    enableJsonResponse: true,
+    maxRequestBodySize: MAX_REQUEST_BODY_SIZE
+  });
   await server2.connect(transport);
   try {
     return await transport.handleRequest(request, {
@@ -12685,6 +12378,25 @@ import { compress } from "hono/compress";
 import { streamSSE as streamSSE2 } from "hono/streaming";
 import { z as z19, ZodError } from "zod";
 
+// apps/server/dist/body-limit.js
+import { bodyLimit } from "hono/body-limit";
+var ENROLL_BODY_LIMIT_BYTES = 16 * 1024;
+var API_BODY_LIMIT_BYTES = 1024 * 1024;
+var RUNNER_BODY_LIMIT_BYTES = 8 * 1024 * 1024;
+var RUNNER_ANSWER_LIMIT_BYTES = 16 * 1024 * 1024;
+function limitBody(maxSize) {
+  return bodyLimit({
+    maxSize,
+    onError: (c) => {
+      c.header("connection", "close");
+      return c.json({
+        error: "PAYLOAD_TOO_LARGE",
+        message: `the request body is over the ${maxSize} bytes this route takes`
+      }, 413);
+    }
+  });
+}
+
 // apps/server/dist/github-auth.js
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { Hono } from "hono";
@@ -12706,9 +12418,21 @@ function githubAvatar(url) {
     return void 0;
   }
 }
+var BOARD_ORIGIN = "https://board.invalid";
 function safeNext(next) {
-  return next !== void 0 && /^\/(?![/\\])/.test(next) ? next : "/";
+  if (next === void 0 || !next.startsWith("/")) {
+    return "/";
+  }
+  let url;
+  try {
+    url = new URL(next, BOARD_ORIGIN);
+  } catch {
+    return "/";
+  }
+  const path11 = `${url.pathname}${url.search}`;
+  return url.origin === BOARD_ORIGIN && /^\/(?![/\\])/.test(path11) ? path11 : "/";
 }
+var APP_LANDING = "stellaris://signin";
 function land(c, next, fragment) {
   return c.redirect(`${next}#${fragment}`, 302);
 }
@@ -12729,7 +12453,8 @@ function githubAuthRoutes(options) {
       }
     }
     const state = randomBytes2(24).toString("base64url");
-    states.set(state, { next: safeNext(c.req.query("next")), expiresAt: now() + STATE_TTL_MS });
+    const next = c.req.query("landing") === "app" ? APP_LANDING : safeNext(c.req.query("next"));
+    states.set(state, { next, expiresAt: now() + STATE_TTL_MS });
     const authorize = new URL("https://github.com/login/oauth/authorize");
     authorize.searchParams.set("client_id", github.clientId);
     authorize.searchParams.set("state", state);
@@ -12992,8 +12717,9 @@ function bearer(c) {
 function runnerRoutes(board2, hub, enrollments, enrollLimit) {
   const routes = new Hono2();
   if (enrollments !== void 0) {
-    routes.post("/enroll", enrollLimit ?? ((_c, next) => next()), async (c) => c.json(enrollments.open(RunnerEnrollRequestSchema.parse(await c.req.json()))));
-    routes.post("/enroll/poll", async (c) => {
+    const enrollBody = limitBody(ENROLL_BODY_LIMIT_BYTES);
+    routes.post("/enroll", enrollLimit ?? ((_c, next) => next()), enrollBody, async (c) => c.json(enrollments.open(RunnerEnrollRequestSchema.parse(await c.req.json()))));
+    routes.post("/enroll/poll", enrollBody, async (c) => {
       const { deviceCode } = RunnerEnrollPollSchema.parse(await c.req.json());
       const status = enrollments.poll(deviceCode);
       return status === null ? c.json({ error: "NOT_FOUND", message: "no such enrollment; it may have expired" }, 404) : c.json(status);
@@ -13008,7 +12734,8 @@ function runnerRoutes(board2, hub, enrollments, enrollLimit) {
     c.set("runner", runner);
     await next();
   });
-  routes.post("/hello", async (c) => c.json(await hub.register(c.get("runner"), RunnerHelloSchema.parse(await c.req.json()))));
+  const body = limitBody(RUNNER_BODY_LIMIT_BYTES);
+  routes.post("/hello", body, async (c) => c.json(await hub.register(c.get("runner"), RunnerHelloSchema.parse(await c.req.json()))));
   routes.get("/stream", (c) => {
     const runner = c.get("runner");
     return streamSSE(c, async (stream) => {
@@ -13046,7 +12773,7 @@ function runnerRoutes(board2, hub, enrollments, enrollLimit) {
       }
     });
   });
-  routes.post("/turns/:id/events", async (c) => {
+  routes.post("/turns/:id/events", body, async (c) => {
     const { entries } = TurnEventsSchema.parse(await c.req.json());
     await hub.turnEvents(c.get("runner"), UlidSchema.parse(c.req.param("id")), entries);
     return c.json({ ok: true });
@@ -13055,21 +12782,21 @@ function runnerRoutes(board2, hub, enrollments, enrollLimit) {
     hub.received(c.get("runner"), UlidSchema.parse(c.req.param("id")));
     return c.json({ ok: true });
   });
-  routes.post("/turns/:id/outcome", async (c) => c.json(await hub.turnOutcome(c.get("runner"), UlidSchema.parse(c.req.param("id")), TurnOutcomeSchema.parse(await c.req.json()))));
-  routes.post("/requests/:id", async (c) => {
+  routes.post("/turns/:id/outcome", body, async (c) => c.json(await hub.turnOutcome(c.get("runner"), UlidSchema.parse(c.req.param("id")), TurnOutcomeSchema.parse(await c.req.json()))));
+  routes.post("/requests/:id", limitBody(RUNNER_ANSWER_LIMIT_BYTES), async (c) => {
     hub.answer(c.get("runner"), c.req.param("id"), RunnerAnswerSchema.parse(await c.req.json()));
     return c.json({ ok: true });
   });
-  routes.post("/workspaces", async (c) => {
+  routes.post("/workspaces", body, async (c) => {
     hub.heldWorkspaces(c.get("runner"), HeldWorkspacesSchema.parse(await c.req.json()).workspaces);
     return c.json({ ok: true });
   });
-  routes.post("/warm", async (c) => {
+  routes.post("/warm", body, async (c) => {
     hub.warmChanged(c.get("runner"), WarmSessionsSchema.parse(await c.req.json()).warm);
     return c.json({ ok: true });
   });
   routes.get("/board/manifest", async (c) => c.json({ files: await board2.boardManifest() }));
-  routes.post("/board/read", async (c) => c.json({ files: await board2.readBoardFiles(FileReadSchema.parse(await c.req.json()).paths) }));
+  routes.post("/board/read", body, async (c) => c.json({ files: await board2.readBoardFiles(FileReadSchema.parse(await c.req.json()).paths) }));
   const home = new Hono2();
   home.use("*", async (c, next) => {
     const agent = NameSchema.parse(c.req.param("agent"));
@@ -13221,6 +12948,7 @@ function createApp(deps) {
   };
   const api = new Hono3();
   api.use("*", authenticate);
+  api.on(["POST", "PUT", "PATCH", "DELETE"], "*", limitBody(API_BODY_LIMIT_BYTES));
   api.get("/me", (c) => {
     const signIn = board2.signInOf(bearer2(c) ?? "");
     return c.json(signIn === null ? c.get("actor") : {
@@ -13370,14 +13098,23 @@ function createApp(deps) {
   api.get("/projects/:slug/tasks", async (c) => c.json(await board2.listTasks(c.req.param("slug"))));
   api.get("/projects/:slug/dashboard", async (c) => c.json(await board2.readDashboard(c.req.param("slug"))));
   api.get("/projects/:slug/knowledge", async (c) => c.json(await board2.listKnowledge(c.req.param("slug"))));
+  const branchFile = async (c, project, branch, file) => {
+    if (deps.runners === void 0) {
+      throw new BoardError("NOT_FOUND", "this board has no runners to read files from");
+    }
+    return c.json(await deps.runners.readBranch(project, branch, BranchPathSchema.parse(file)));
+  };
+  const projectFile = async (c, file) => {
+    const project = await board2.readProject(NameSchema.parse(c.req.param("slug")));
+    return branchFile(c, project.slug, project.defaultBranch, file);
+  };
+  api.get("/projects/:slug/files", (c) => projectFile(c, ""));
+  api.get("/projects/:slug/files/:path{.+}", (c) => projectFile(c, c.req.param("path")));
   api.get("/tasks/:id", async (c) => c.json((await board2.findTask(c.req.param("id"))).task));
   api.get("/tasks/:id/thread", async (c) => c.json(await board2.listThread(c.req.param("id"))));
   const taskFile = async (c, file) => {
     const { task } = await board2.findTask(UlidSchema.parse(c.req.param("id")));
-    if (deps.runners === void 0) {
-      throw new BoardError("NOT_FOUND", "this board has no runners to read a task's files from");
-    }
-    return c.json(await deps.runners.readBranch(task.project, `task/${task.id}`, BranchPathSchema.parse(file)));
+    return branchFile(c, task.project, `task/${task.id}`, file);
   };
   api.get("/tasks/:id/files", (c) => taskFile(c, ""));
   api.get("/tasks/:id/changes", async (c) => {