@kubitnodes/stellaris 0.3.23 → 0.3.25

package/dist/server/index.js

@@ -2,12 +2,12 @@
 
 // apps/server/dist/index.js
 import { access as access2 } from "node:fs/promises";
-import path9 from "node:path";
+import path10 from "node:path";
 import { serve } from "@hono/node-server";
 
 // packages/board-core/dist/board.js
-import { chmod as chmod2, cp, mkdir as mkdir4, readdir as readdir3, readFile as readFile4, rename as rename3, rm as rm2, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
-import path6 from "node:path";
+import { chmod as chmod2, cp, mkdir as mkdir4, readdir as readdir4, readFile as readFile4, rename as rename3, rm as rm2, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
+import path7 from "node:path";
 import { decodeTime, monotonicFactory } from "ulid";
 import { z as z16 } from "zod";
 
@@ -235,6 +235,7 @@ var CronFrontmatterSchema = z3.object({
   scope: NameSchema,
   thread: UlidSchema.optional(),
   channel: NameSchema.optional(),
+  place: NameSchema.optional(),
   schedule: CronScheduleSchema,
   createdBy: NameSchema,
   createdAt: IsoDateTimeSchema,
@@ -384,15 +385,16 @@ function quotaLevel(quota, now) {
 var WINDOW_NAMES = {
   five_hour: "5h",
   seven_day: "7d",
-  seven_day_opus: "7d Opus",
-  seven_day_sonnet: "7d Sonnet",
+  seven_day_opus: "7d opus",
+  seven_day_sonnet: "7d sonnet",
   seven_day_oauth_apps: "7d apps",
   seven_day_overage_included: "7d extra",
   overage: "extra usage"
 };
 function windowName(window) {
   if (window.label !== void 0) {
-    return window.minutes === 10080 ? `7d ${window.label}` : window.label;
+    const label = window.label.toLowerCase();
+    return window.minutes === 10080 ? `7d ${label}` : label;
   }
   const named = WINDOW_NAMES[window.key];
   if (named !== void 0) {
@@ -766,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,
@@ -811,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,
@@ -889,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);
@@ -991,7 +987,8 @@ var DashboardSchema = z5.object({
 var ProposalOriginSchema = z5.object({
   scope: NameSchema,
   thread: UlidSchema.optional(),
-  channel: NameSchema.optional()
+  channel: NameSchema.optional(),
+  place: NameSchema.optional()
 });
 var SKILL_FILES_LIMIT = 100;
 var SKILL_BYTES_LIMIT = 10 * 1024 * 1024;
@@ -1106,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({
@@ -1385,6 +1380,7 @@ var TurnExitReasonSchema = z8.enum([
   "blocked",
   "stopped"
 ]);
+var ResumeFailureSchema = z8.enum(["lost", "retry"]);
 var AgentEventSchema = z8.discriminatedUnion("type", [
   z8.object({
     type: z8.literal("turn_started"),
@@ -1436,6 +1432,8 @@ var LiveTurnEventSchema = z8.object({
   thread: UlidSchema.optional(),
   /** The channel, never general, whose conversation the turn is in. */
   channel: NameSchema.optional(),
+  /** The project whose channels' conversation the turn is in, for a turn in the society scope. */
+  place: NameSchema.optional(),
   event: AgentEventSchema
 });
 
@@ -1538,7 +1536,8 @@ var TurnWorkspaceSchema = z9.discriminatedUnion("kind", [
   z9.object({
     kind: z9.literal("home"),
     thread: UlidSchema.optional(),
-    channel: NameSchema.optional()
+    channel: NameSchema.optional(),
+    place: NameSchema.optional()
   }),
   z9.object({
     kind: z9.literal("project"),
@@ -1547,7 +1546,16 @@ var TurnWorkspaceSchema = z9.discriminatedUnion("kind", [
     thread: UlidSchema.optional(),
     channel: NameSchema.optional()
   }),
-  z9.object({ kind: z9.literal("task"), repo: ProjectRepoSchema, taskId: UlidSchema })
+  z9.object({
+    kind: z9.literal("task"),
+    repo: ProjectRepoSchema,
+    taskId: UlidSchema,
+    /**
+     * The citizen holding the task's current stage, when someone does: a turn of anyone else
+     * works detached at the branch's tip, so the holder's turns find the branch free.
+     */
+    holder: NameSchema.optional()
+  })
 ]);
 var TurnJobSchema = z9.object({
   turnId: UlidSchema,
@@ -1563,6 +1571,8 @@ var TurnJobSchema = z9.object({
   thread: UlidSchema.optional(),
   /** The channel, never general, whose conversation the turn is in. */
   channel: NameSchema.optional(),
+  /** The project whose channels' conversation the turn is in, for a turn in the society scope. */
+  place: NameSchema.optional(),
   /**
    * The session to resume, or null to start one: the CLI's adapter picks a fresh session's id, and
    * the outcome reports it.
@@ -1583,6 +1593,12 @@ var TurnJobSchema = z9.object({
   workspace: TurnWorkspaceSchema
 });
 var TurnWorkSchema = z9.object({ branch: z9.string().min(1), head: z9.string().min(1) });
+var StuckWorkSchema = z9.object({
+  branch: z9.string().min(1),
+  agent: NameSchema,
+  commits: z9.array(z9.string()),
+  total: z9.number().int().positive()
+});
 var TurnEventsSchema = z9.object({ entries: z9.array(TranscriptEntrySchema) });
 var TurnOutcomeSchema = z9.object({
   exitReason: TurnExitReasonSchema,
@@ -1592,8 +1608,24 @@ var TurnOutcomeSchema = z9.object({
   costUsd: z9.number().nonnegative(),
   /** The session's running total after this turn, for CLIs that report one. */
   sessionCostUsd: z9.number().nonnegative().optional(),
-  /** The session the CLI used, which differs from the job's for CLIs that assign their own ids. */
-  session: z9.string().min(1),
+  /**
+   * The session the CLI used, which differs from the job's for CLIs that assign their own ids. A
+   * turn whose CLI never started, because it failed or was stopped first, reports the job's own,
+   * null in a conversation's first turn, so a session never started is not recorded.
+   */
+  session: z9.string().min(1).nullable(),
+  /**
+   * Set when the CLI could not resume the job's session, which failed the turn before any model
+   * call; the server then drops a `lost` session, and one that failed `retry` too often in a row. A
+   * 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(),
@@ -1602,6 +1634,11 @@ var TurnOutcomeSchema = z9.object({
    * branch after the hand-back: uncommitted changes, or commits no branch contains.
    */
   leftovers: z9.boolean().default(false),
+  /**
+   * Commits the hand-back found its task's worktrees holding that no fast-forward of the task's
+   * branch can take, each told once; a runner from before never sends it.
+   */
+  stuck: z9.array(StuckWorkSchema).optional(),
   /**
    * The CLI's plan quota as the turn's stream last reported it, when it reported any; a runner from
    * before never sends it.
@@ -1720,13 +1757,17 @@ var TurnImageSchema = z9.discriminatedUnion("kind", [
 ]);
 var WorkspaceConversationSchema = z9.discriminatedUnion("kind", [
   z9.object({ kind: z9.literal("thread"), id: UlidSchema }),
-  z9.object({ kind: z9.literal("channel"), scope: NameSchema, name: NameSchema })
+  z9.object({ kind: z9.literal("channel"), scope: NameSchema, name: NameSchema }),
+  z9.object({ kind: z9.literal("place"), project: NameSchema })
 ]);
 function workspaceConversationOf(turn) {
   if (turn.thread !== void 0) {
     return { kind: "thread", id: turn.thread };
   }
-  return turn.channel === void 0 ? null : { kind: "channel", scope: turn.scope, name: turn.channel };
+  if (turn.channel !== void 0) {
+    return { kind: "channel", scope: turn.scope, name: turn.channel };
+  }
+  return turn.place === void 0 ? null : { kind: "place", project: turn.place };
 }
 var HeldWorkspaceSchema = z9.object({
   agent: NameSchema,
@@ -1832,6 +1873,7 @@ var TurnDispatchSchema = z10.object({
   project: NameSchema,
   thread: TurnThreadSchema.optional(),
   channel: NameSchema.optional(),
+  place: NameSchema.optional(),
   trigger: TriggerSchema,
   priority: z10.number().int().min(0).max(2),
   onboarding: z10.boolean().default(false),
@@ -1839,7 +1881,13 @@ var TurnDispatchSchema = z10.object({
   crons: z10.array(UlidSchema).optional()
 });
 function conversationPart(conversation) {
-  return conversation.thread ?? (conversation.channel === void 0 ? void 0 : `#${conversation.channel}`);
+  if (conversation.thread !== void 0) {
+    return conversation.thread;
+  }
+  if (conversation.channel !== void 0) {
+    return `#${conversation.channel}`;
+  }
+  return conversation.place === void 0 ? void 0 : `~${conversation.place}`;
 }
 function sessionKey(agent, scope, part) {
   return part === void 0 ? `${agent}/${scope}` : `${agent}/${scope}/${part}`;
@@ -1852,7 +1900,10 @@ function parseSessionKey(key) {
   if (part === void 0) {
     return { agent, scope };
   }
-  return part.startsWith("#") ? { agent, scope, channel: part.slice(1) } : { agent, scope, thread: part };
+  if (part.startsWith("#")) {
+    return { agent, scope, channel: part.slice(1) };
+  }
+  return part.startsWith("~") ? { agent, scope, place: part.slice(1) } : { agent, scope, thread: part };
 }
 function channelConversation(scope, channel) {
   const at = channel.indexOf("/");
@@ -1860,6 +1911,10 @@ function channelConversation(scope, channel) {
   const name = at < 0 ? channel : channel.slice(at + 1);
   return place === scope && name !== "general" ? name : void 0;
 }
+function placeConversation(scope, channel) {
+  const at = channel.indexOf("/");
+  return scope === SOCIETY_SCOPE && at >= 0 ? channel.slice(0, at) : void 0;
+}
 var TurnRecordSchema = z10.object({
   /** Assigned by the board when the turn begins; the turn's transcript is filed under it. */
   id: UlidSchema.optional(),
@@ -1869,6 +1924,8 @@ var TurnRecordSchema = z10.object({
   thread: UlidSchema.optional(),
   /** The channel, never general, whose conversation the turn was in. */
   channel: NameSchema.optional(),
+  /** The project whose channels' conversation the turn was in, for a turn in the society scope. */
+  place: NameSchema.optional(),
   runner: NameSchema,
   cli: CliKindSchema.nullable(),
   session: z10.string().nullable(),
@@ -1892,6 +1949,14 @@ var TurnRecordSchema = z10.object({
   work: TurnWorkSchema.optional(),
   /** Who stopped the turn, for one that ended `stopped`. */
   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. */
+  sessionDropped: z10.boolean().optional(),
   /** The crons whose fire started the turn, which record how it ended. */
   crons: z10.array(UlidSchema).optional()
 });
@@ -1901,6 +1966,7 @@ var RunningTurnSchema = z10.object({
   scope: NameSchema,
   thread: UlidSchema.optional(),
   channel: NameSchema.optional(),
+  place: NameSchema.optional(),
   cli: CliKindSchema,
   askedIn: ChannelRefSchema.optional(),
   steerable: z10.boolean(),
@@ -1931,6 +1997,8 @@ var TurnHistoryEntrySchema = z10.object({
   thread: UlidSchema.optional(),
   /** The channel, never general, whose conversation the turn was in. */
   channel: NameSchema.optional(),
+  /** The project whose channels' conversation the turn was in, for a turn in the society scope. */
+  place: NameSchema.optional(),
   trigger: z10.string(),
   exitReason: z10.string().nullable(),
   costUsd: z10.number(),
@@ -1959,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 = [
@@ -1983,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";
@@ -2178,7 +2257,7 @@ var RunnerConfigSchema = z13.object({
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.3.23";
+var STELLARIS_VERSION = "0.3.25";
 
 // packages/shared/dist/mentions.js
 import { parse, postprocess, preprocess } from "micromark";
@@ -2562,6 +2641,7 @@ var HOME_GITIGNORE = [
   "/projects/*/last-turn.json",
   "/projects/*/threads/",
   "/projects/*/channels/",
+  "/projects/*/places/",
   `/${HOME_SCRATCH}/`,
   "*.tmp",
   "node_modules/",
@@ -2579,7 +2659,7 @@ var HOME_GITIGNORE = [
 var IGNORE_FILE = `${HOME_GITIGNORE.join("\n")}
 `;
 var PRE_RECEIVE = `#!/bin/sh
-forbidden='^(agent\\.json|cursors\\.json|role\\.md|turns/|\\.claude/|\\.codex/|projects/[^/]+/(sessions[^/]*\\.json|last-turn\\.json|threads/|channels/))'
+forbidden='^(agent\\.json|cursors\\.json|role\\.md|turns/|\\.claude/|\\.codex/|projects/[^/]+/(sessions[^/]*\\.json|last-turn\\.json|threads/|channels/|places/))'
 while read old new ref; do
   if [ "$ref" != "refs/heads/main" ]; then
     echo "a home takes pushes to main only" >&2
@@ -2905,6 +2985,7 @@ var TurnPayload = z14.object({
   project: z14.string(),
   thread: z14.string().optional(),
   channel: z14.string().optional(),
+  place: z14.string().optional(),
   trigger: z14.string()
 });
 var TaskPayload = z14.object({
@@ -2950,11 +3031,16 @@ function answers(mention, turn) {
   if (!mention.scopes.includes(turn.project)) {
     return false;
   }
-  const own = mention.thread === null ? channelConversation(turn.project, mention.channel) : void 0;
+  const topLevel = mention.thread === null;
+  const own = topLevel ? channelConversation(turn.project, mention.channel) : void 0;
+  const place = topLevel ? placeConversation(turn.project, mention.channel) : void 0;
   if (turn.channel !== null) {
-    return mention.thread === null && own === turn.channel;
+    return topLevel && own === turn.channel;
+  }
+  if (turn.place !== null) {
+    return topLevel && place === turn.place;
   }
-  return mention.thread === null && own === void 0 || turn.trigger === "mention";
+  return topLevel && own === void 0 && place === void 0 || turn.trigger === "mention";
 }
 function computeMetrics(input) {
   const { events, now, window } = input;
@@ -3020,6 +3106,7 @@ function computeMetrics(input) {
           at,
           thread: turn.data.thread ?? null,
           channel: turn.data.channel ?? null,
+          place: turn.data.place ?? null,
           project: turn.data.project,
           trigger: turn.data.trigger
         };
@@ -3219,6 +3306,7 @@ var TurnHistoryPayloadSchema = z15.object({
   project: NameSchema,
   thread: UlidSchema.optional(),
   channel: NameSchema.optional(),
+  place: NameSchema.optional(),
   trigger: z15.string().default("manual"),
   exitReason: z15.string().nullable().default(null),
   costUsd: z15.number().default(0),
@@ -3457,11 +3545,14 @@ var BoardPaths = class {
     return path5.join(this.agentProjects(name), slug);
   }
   /**
-   * A thread's or a channel's conversation's session and last turn, beside the scope's home
-   * conversation; `part` is a thread's id or `#channel`.
+   * A thread's, a channel's, or, in the society scope, a project's conversation's session and last
+   * turn, beside the scope's home conversation; `part` is a thread's id, `#channel`, or `~project`.
    */
   agentConversation(name, slug, part) {
-    return part.startsWith("#") ? path5.join(this.agentProject(name, slug), "channels", part.slice(1)) : path5.join(this.agentProject(name, slug), "threads", part);
+    if (part.startsWith("#")) {
+      return path5.join(this.agentProject(name, slug), "channels", part.slice(1));
+    }
+    return part.startsWith("~") ? path5.join(this.agentProject(name, slug), "places", part.slice(1)) : path5.join(this.agentProject(name, slug), "threads", part);
   }
   agentCursors(name) {
     return path5.join(this.agent(name), "cursors.json");
@@ -3495,6 +3586,111 @@ var BoardPaths = class {
   }
 };
 
+// packages/board-core/dist/skill-folder.js
+import { constants } from "node:fs";
+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;
+function skillFileText(bytes) {
+  const text = bytes.includes(0) ? null : bytes.toString("utf8");
+  return {
+    text: text === null ? null : text.slice(0, SKILL_TEXT_LIMIT_CHARS),
+    truncated: text !== null && text.length > SKILL_TEXT_LIMIT_CHARS
+  };
+}
+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
+  }).catch(() => []);
+  for (const entry of entries.toSorted((a, b) => a.name < b.name ? -1 : 1)) {
+    if (found.length >= SKILL_FILES_LIMIT) {
+      return;
+    }
+    const relative = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+    if (!isSafeRelativePath(relative)) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      await walk(root, relative, found);
+    } else if (entry.isFile() && !entry.name.endsWith(".tmp")) {
+      found.push(relative);
+    }
+  }
+}
+async function readEntry(root, relative) {
+  let real;
+  try {
+    real = await realpath(path6.join(root, ...relative.split("/")));
+  } catch {
+    return null;
+  }
+  if (!inside(root, real)) {
+    return null;
+  }
+  const handle = await open2(real, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK).catch(() => null);
+  if (handle === null) {
+    return null;
+  }
+  try {
+    if (!await handleInside(root, handle)) {
+      return null;
+    }
+    const stats = await handle.stat();
+    if (!stats.isFile()) {
+      return null;
+    }
+    const buffer = Buffer.alloc(Math.min(stats.size, SKILL_TEXT_LIMIT_BYTES));
+    let size = 0;
+    while (size < buffer.length) {
+      const { bytesRead } = await handle.read(buffer, size, buffer.length - size, size);
+      if (bytesRead === 0) {
+        break;
+      }
+      size += bytesRead;
+    }
+    return {
+      path: relative,
+      size: stats.size,
+      executable: (stats.mode & 73) !== 0,
+      ...skillFileText(buffer.subarray(0, size))
+    };
+  } finally {
+    await handle.close();
+  }
+}
+async function readSkillFolder(dir) {
+  const info = await lstat(dir).catch(() => null);
+  if (info === null || !info.isDirectory()) {
+    return null;
+  }
+  const root = await realpath(dir).catch(() => null);
+  if (root === null) {
+    return null;
+  }
+  const found = [];
+  await walk(root, "", found);
+  const files = [];
+  for (const relative of found) {
+    const file = await readEntry(root, relative);
+    if (file !== null) {
+      files.push(file);
+    }
+  }
+  return files.some((file) => file.path === "SKILL.md") ? files : null;
+}
+
 // packages/board-core/dist/tokens.js
 import { createHash as createHash2, randomBytes } from "node:crypto";
 function mintToken() {
@@ -3508,7 +3704,7 @@ function hashToken(token) {
 var SYSTEM_ACTOR = { name: "board", role: USER_ROLE };
 var CLOSING_ATTEMPTS = 3;
 function ownTurn(actor, turn) {
-  return turn.agent === actor.name && turn.scope === actor.scope && turn.thread === actor.thread && turn.channel === actor.channel;
+  return turn.agent === actor.name && turn.scope === actor.scope && turn.thread === actor.thread && turn.channel === actor.channel && turn.place === actor.place;
 }
 function namesList(names) {
   return names.length <= 1 ? names[0] ?? "" : `${names.slice(0, -1).join(", ")} and ${names.at(-1) ?? ""}`;
@@ -3521,37 +3717,45 @@ 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. */
   news: z16.string().optional()
 });
-var NO_CURSORS = { digest: null, scopes: {}, threadsFrom: {}, channelsFrom: {} };
+var NO_CURSORS = {
+  digest: null,
+  scopes: {},
+  channelsFrom: {},
+  placesFrom: {}
+};
 function conversationKey(scope, part) {
   return part === null ? scope : `${scope}/${part}`;
 }
 function channelOfPart(part) {
   return part?.startsWith("#") === true ? part.slice(1) : void 0;
 }
+function placeOfPart(part) {
+  return part?.startsWith("~") === true ? part.slice(1) : void 0;
+}
 function threadOfPart(part) {
-  return part === null || part === void 0 || part.startsWith("#") ? void 0 : part;
+  return part === null || part === void 0 || part.startsWith("#") || part.startsWith("~") ? void 0 : part;
 }
 function channelStart(cursors, scope) {
   const from = cursors.channelsFrom[scope];
   return from === void 0 ? cursors.digest : from;
 }
-function threadStart(cursors, scope) {
-  const from = cursors.threadsFrom[scope];
+function placeStart(cursors, scope) {
+  const from = cursors.placesFrom[scope];
   return from === void 0 ? cursors.digest : from;
 }
 function newsStart(cursors) {
@@ -3565,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) : 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;
@@ -3573,21 +3777,23 @@ function byId(a, b) {
 function turnTime(record) {
   return record.endedAt ?? record.startedAt;
 }
+function turnConversation(record) {
+  return record.thread !== void 0 ? ` in thread ${record.thread}` : record.channel !== void 0 ? ` in #${record.channel}` : record.place !== void 0 ? ` in ${record.place}'s channels` : "";
+}
 var PausedSchema = z16.object({ paused: z16.boolean() });
 var DEFAULT_LEASE_MS = 30 * 60 * 1e3;
 function withoutMentions(text) {
   return text.replaceAll(MENTION_PATTERN, "$1$2");
 }
-var SKILL_TEXT_LIMIT_CHARS = 1e5;
 function skillFolderOf(proposal) {
   if (proposal.kind !== "skill") {
     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;
+  return origin !== void 0 && origin.scope === where.scope && origin.thread === where.thread && origin.channel === where.channel && origin.place === where.place;
 }
 function megabytes(bytes) {
   return (bytes / (1024 * 1024)).toFixed(1).replace(/\.0$/, "");
@@ -3599,27 +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 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"];
@@ -3639,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("#")) ?? "";
 }
@@ -3683,8 +3868,8 @@ function restage(existing, edit) {
   };
 }
 function reopenStage(stage) {
-  const { completedBy: _by, completedAt: _at, ...open2 } = stage;
-  return open2;
+  const { completedBy: _by, completedAt: _at, ...open3 } = stage;
+  return open3;
 }
 function gateChanges(before, after) {
   const changes = [];
@@ -3765,7 +3950,7 @@ var Board = class _Board {
   homes;
   constructor(dataDir, options) {
     this.paths = new BoardPaths(dataDir);
-    this.homes = new HomeRepos(path6.join(this.paths.state(), "home-hooks"));
+    this.homes = new HomeRepos(path7.join(this.paths.state(), "home-hooks"));
     this.leaseMs = options.leaseMs ?? DEFAULT_LEASE_MS;
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
     this.events = new EventLog(this.paths.eventLog(), () => this.newId(), this.now);
@@ -3794,368 +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 file = path6.join(this.paths.state(), "alignments.json");
+    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
-    ].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");
-    }
-    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(path6.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 open2 = 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: open2 ? "open" : "closed",
-            openedBy: openedBy?.actor ?? task.createdBy,
-            openedAt: openedBy?.ts ?? task.createdAt,
-            ...open2 ? {} : {
-              closedBy: closedBy?.actor ?? SYSTEM_ACTOR.name,
-              closedAt: closedBy?.ts ?? this.now().toISOString()
-            },
-            body: summaries.get(task.id) ?? ""
-          });
-        }
-        await this.writeTask(slug, task);
-      }
+    for (const { apply } of pending) {
+      await apply();
     }
-  }
-  /**
-   * 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 });
-    }
-  }
-  /**
-   * 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() {
@@ -4257,13 +4096,15 @@ ${charter.purpose}
     const token = mintToken();
     const thread = threadOfPart(part);
     const channel = channelOfPart(part);
+    const place = placeOfPart(part);
     this.turnTokens.set(hashToken(token), {
       actor: {
         name: agent,
         role,
         ...scope === void 0 ? {} : { scope },
         ...thread === void 0 ? {} : { thread },
-        ...channel === void 0 ? {} : { channel }
+        ...channel === void 0 ? {} : { channel },
+        ...place === void 0 ? {} : { place }
       },
       expiresAt: this.now().getTime() + ttlMs
     });
@@ -4352,7 +4193,7 @@ ${charter.purpose}
     });
   }
   signInsFile() {
-    return path6.join(this.paths.state(), "sign-ins.json");
+    return path7.join(this.paths.state(), "sign-ins.json");
   }
   async readSignIns() {
     const file = this.signInsFile();
@@ -4449,7 +4290,7 @@ ${charter.purpose}
     const files = await listFiles(this.paths.tasks(project));
     const tasks = [];
     for (const file of files) {
-      const doc = await readMarkdown(path6.join(this.paths.tasks(project), file), TaskFrontmatterSchema);
+      const doc = await readMarkdown(path7.join(this.paths.tasks(project), file), TaskFrontmatterSchema);
       tasks.push({ ...doc.data, body: doc.body });
     }
     return tasks;
@@ -4468,7 +4309,7 @@ ${charter.purpose}
     const files = await listFiles(this.paths.proposals());
     const proposals = [];
     for (const file of files) {
-      const doc = await readMarkdown(path6.join(this.paths.proposals(), file), ProposalFrontmatterSchema);
+      const doc = await readMarkdown(path7.join(this.paths.proposals(), file), ProposalFrontmatterSchema);
       proposals.push({ ...doc.data, body: doc.body });
     }
     return proposals;
@@ -4495,7 +4336,7 @@ ${charter.purpose}
   async listMembers() {
     const members = [];
     for (const file of await listFiles(this.paths.members())) {
-      const doc = await readMarkdown(path6.join(this.paths.members(), file), MemberSchema);
+      const doc = await readMarkdown(path7.join(this.paths.members(), file), MemberSchema);
       members.push({ ...doc.data, profile: doc.body });
     }
     return members;
@@ -4514,7 +4355,7 @@ ${charter.purpose}
     const dir = project === null ? this.paths.societyKnowledge() : this.paths.projectKnowledge(project);
     const topics = [];
     for (const file of await listFiles(dir)) {
-      topics.push(await this.knowledgeAt(path6.join(dir, file), project, file.replace(/\.md$/, "")));
+      topics.push(await this.knowledgeAt(path7.join(dir, file), project, file.replace(/\.md$/, "")));
     }
     return topics;
   }
@@ -4544,7 +4385,7 @@ ${charter.purpose}
     const aside = this.paths.removedKnowledge(project ?? SOCIETY_SCOPE);
     let highest = 0;
     for (const file of (await listFiles(aside)).filter((name) => name.startsWith(`${topic}.`))) {
-      const copy = await this.knowledgeAt(path6.join(aside, file), project, topic);
+      const copy = await this.knowledgeAt(path7.join(aside, file), project, topic);
       highest = Math.max(highest, copy.revision);
     }
     return highest;
@@ -4560,7 +4401,7 @@ ${charter.purpose}
   async listSkillsIn(dir, scope) {
     const skills = [];
     for (const entry of await listDirs(dir)) {
-      const file = path6.join(dir, entry, "SKILL.md");
+      const file = path7.join(dir, entry, "SKILL.md");
       if (!await exists(file)) {
         continue;
       }
@@ -4650,7 +4491,7 @@ ${charter.purpose}
         if (!wanted.delete(file.slice(0, 26))) {
           continue;
         }
-        const { data } = await readMarkdown(path6.join(dir, file), MessageFrontmatterSchema);
+        const { data } = await readMarkdown(path7.join(dir, file), MessageFrontmatterSchema);
         found.push(MessageRefSchema.parse(data));
       }
       if (wanted.size === 0) {
@@ -4682,7 +4523,7 @@ ${charter.purpose}
         if (!file.endsWith(".md")) {
           continue;
         }
-        const doc = await readMarkdown(path6.join(threads, file), ThreadFrontmatterSchema);
+        const doc = await readMarkdown(path7.join(threads, file), ThreadFrontmatterSchema);
         if (doc.data.state !== "open") {
           continue;
         }
@@ -4709,7 +4550,7 @@ ${charter.purpose}
     const all = [];
     for (const threads of await this.threadScopes()) {
       for (const file of await listFiles(threads)) {
-        const doc = await readMarkdown(path6.join(threads, file), ThreadFrontmatterSchema);
+        const doc = await readMarkdown(path7.join(threads, file), ThreadFrontmatterSchema);
         const messages = await listFiles(this.paths.threadMessages(threads, doc.data.id));
         const last = messages.at(-1);
         all.push({
@@ -4957,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") {
@@ -4965,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,
@@ -5076,16 +4919,20 @@ ${DASHBOARD_LINE}
   }
   /**
    * How many unread digest messages a member has in each conversation: a scope's home, for its
-   * general channel, one of its other channels, or one of its threads. The heartbeat asks, so that it wakes a member where its unread
+   * general channel, one of its other channels, one of its threads, or, in the society scope, a
+   * project's channels. The heartbeat asks, so that it wakes a member where its unread
    * messages are and nowhere else. Society channels count only for a member woken in the society
    * scope; a project member reads them at its next turn. Two kinds of post are in the digest but not
    * counted, and are read when the member wakes for something else: a task step's, which wakes
    * whoever it hands work to, and the board's own, operations signals and landing announcements,
-   * whose signals that call for action wake their readers directly.
+   * whose signals that call for action wake their readers directly. A closed thread counts for
+   * nothing: its conversation has ended, and a turn there could only read its posts and be refused
+   * a reply, while a wake queued before it closed, as for a mention, still runs there.
    */
   async unreadByConversation(actor) {
     const { cursors, upto } = await this.digestSnapshot(actor.name);
     const counts = /* @__PURE__ */ new Map();
+    const closed = /* @__PURE__ */ new Map();
     const unscoped = { name: actor.name, role: actor.role };
     for (const { scope, part, message, news } of await this.digestSince(unscoped, cursors, upto)) {
       if (news === true || message.step !== void 0 || message.author === SYSTEM_ACTOR.name) {
@@ -5095,11 +4942,23 @@ ${DASHBOARD_LINE}
       if (posted !== scope && scope !== SOCIETY_SCOPE) {
         continue;
       }
+      const thread = threadOfPart(part);
+      if (thread !== void 0) {
+        let ended = closed.get(thread);
+        if (ended === void 0) {
+          ended = (await this.tryFindThread(thread))?.thread.state === "closed";
+          closed.set(thread, ended);
+        }
+        if (ended) {
+          continue;
+        }
+      }
       const key = conversationKey(scope, part);
       const entry = counts.get(key) ?? {
         scope,
-        thread: threadOfPart(part) ?? null,
+        thread: thread ?? null,
         channel: channelOfPart(part) ?? null,
+        place: placeOfPart(part) ?? null,
         count: 0
       };
       counts.set(key, { ...entry, count: entry.count + 1 });
@@ -5157,8 +5016,9 @@ ${DASHBOARD_LINE}
    * thread it takes part in, and for the front desk, which every post by the user wakes, every post
    * by the user wherever it is. With a conversation, only what is filed there: for a thread, every
    * message of the thread, since the conversation is about it; for a channel's, that channel's
-   * top-level messages; for a scope's home, general's and those of a project the member is not in,
-   * since each thread and each other channel is a conversation of its own. Nothing newer than
+   * top-level messages; for a project's in the society scope, the top-level messages of every
+   * channel of a project the member is not in; for a scope's home, general's, since each thread,
+   * each other channel, and each such project is a conversation of its own. Nothing newer than
    * `upto` counts (see `digestSnapshot`).
    */
   async digestSince(actor, cursors, upto, conversation) {
@@ -5178,11 +5038,17 @@ ${DASHBOARD_LINE}
     const frontDesk = charter.wakeTriggers.includes(FRONT_DESK_TRIGGER);
     const threadParticipation = /* @__PURE__ */ new Map();
     const openChannels = /* @__PURE__ */ new Map();
+    const liveProjects = /* @__PURE__ */ new Map();
     const collected = [];
     const newsFrom = charter.societyScope ? void 0 : newsStart(cursors);
     const scopes = conversation !== void 0 ? [conversation.scope] : [...agent.memberships, SOCIETY_SCOPE];
     const starts = [
-      ...scopes.flatMap((each) => conversation === void 0 ? [cursorOf(cursors, each), threadStart(cursors, each), channelStart(cursors, each)] : [cursorOf(cursors, each, conversation.part)]),
+      ...scopes.flatMap((each) => conversation === void 0 ? [
+        cursorOf(cursors, each),
+        cursors.digest,
+        channelStart(cursors, each),
+        placeStart(cursors, each)
+      ] : [cursorOf(cursors, each, conversation.part)]),
       ...newsFrom === void 0 ? [] : [newsFrom]
     ];
     const known = starts.filter((start) => start !== null);
@@ -5192,7 +5058,7 @@ ${DASHBOARD_LINE}
       const thread = message.thread ?? null;
       const asked = message.mentions.includes(actor.name) || frontDesk && message.author === USER_NAME;
       if (newsFrom !== void 0 && thread === null && filedIn === SOCIETY_SCOPE && !asked) {
-        if ((newsFrom === null || message.id > newsFrom) && subscribed.has(message.channel) && message.author !== actor.name) {
+        if ((conversation === void 0 || conversation.part === null) && (newsFrom === null || message.id > newsFrom) && subscribed.has(message.channel) && message.author !== actor.name) {
           collected.push({
             scope: conversation?.scope ?? SOCIETY_SCOPE,
             part: null,
@@ -5203,12 +5069,18 @@ ${DASHBOARD_LINE}
         continue;
       }
       const named = thread === null ? channelConversation(filedIn, message.channel) : void 0;
-      let open2 = named === void 0 ? void 0 : openChannels.get(message.channel);
-      if (named !== void 0 && open2 === void 0) {
-        open2 = await this.channelOpen(message.channel);
-        openChannels.set(message.channel, open2);
-      }
-      const part = thread ?? (open2 === true ? `#${named}` : null);
+      let open3 = named === void 0 ? void 0 : openChannels.get(message.channel);
+      if (named !== void 0 && open3 === void 0) {
+        open3 = await this.channelOpen(message.channel);
+        openChannels.set(message.channel, open3);
+      }
+      const project = thread === null ? placeConversation(filedIn, message.channel) : void 0;
+      let live = project === void 0 ? void 0 : liveProjects.get(project);
+      if (project !== void 0 && live === void 0) {
+        live = await this.projectLive(project);
+        liveProjects.set(project, live);
+      }
+      const part = thread ?? (open3 === true ? `#${named}` : live === true ? `~${project}` : null);
       if (conversation !== void 0 && (filedIn !== conversation.scope || part !== conversation.part)) {
         continue;
       }
@@ -5273,7 +5145,7 @@ ${task.body}`;
         }
       }
       for (const file of await listFiles(this.paths.projectKnowledge(project))) {
-        const content = await readFile4(path6.join(this.paths.projectKnowledge(project), file), "utf8");
+        const content = await readFile4(path7.join(this.paths.projectKnowledge(project), file), "utf8");
         if (content.toLowerCase().includes(needle)) {
           hits.push({
             kind: "knowledge",
@@ -5294,7 +5166,7 @@ ${task.body}`;
       shared.push({
         kind: "knowledge",
         ref: `society/knowledge/${file}`,
-        file: path6.join(this.paths.societyKnowledge(), file)
+        file: path7.join(this.paths.societyKnowledge(), file)
       });
     }
     for (const skill of await this.listSocietySkills()) {
@@ -5307,7 +5179,7 @@ ${task.body}`;
       shared.push({
         kind: "memory",
         ref: `memory/${file}`,
-        file: path6.join(this.paths.agentMemory(actor.name), file)
+        file: path7.join(this.paths.agentMemory(actor.name), file)
       });
     }
     for (const entry of shared) {
@@ -5397,7 +5269,7 @@ ${current.body}`);
       });
       const aside = this.paths.removedKnowledge(args.project ?? SOCIETY_SCOPE);
       await mkdir4(aside, { recursive: true });
-      await rename3(file, path6.join(aside, `${args.topic}.${removed.removedAt.replaceAll(":", "-")}.md`));
+      await rename3(file, path7.join(aside, `${args.topic}.${removed.removedAt.replaceAll(":", "-")}.md`));
       await this.events.append("knowledge.removed", actor.name, {
         topic: args.topic,
         project: args.project
@@ -5445,7 +5317,7 @@ ${current.body}`);
       });
       const aside = this.paths.removedSkills();
       await mkdir4(aside, { recursive: true });
-      await rename3(this.paths.societySkill(args.name), path6.join(aside, `${args.name}.${removed.removedAt.replaceAll(":", "-")}`));
+      await rename3(this.paths.societySkill(args.name), path7.join(aside, `${args.name}.${removed.removedAt.replaceAll(":", "-")}`));
       await this.events.append("skill.removed", actor.name, {
         name: args.name,
         reason: args.reason
@@ -5522,7 +5394,7 @@ ${current.body}`);
         type,
         size: bytes.byteLength
       });
-      const name = path6.basename(args.path).replaceAll(/[[\]\\\r\n]/g, "");
+      const name = path7.basename(args.path).replaceAll(/[[\]\\\r\n]/g, "");
       return {
         id,
         type,
@@ -5548,7 +5420,7 @@ ${current.body}`);
   async listCrons() {
     const crons = [];
     for (const file of await listFiles(this.paths.crons())) {
-      crons.push(await this.readCronFile(path6.join(this.paths.crons(), file)));
+      crons.push(await this.readCronFile(path7.join(this.paths.crons(), file)));
     }
     return crons;
   }
@@ -5670,11 +5542,16 @@ ${current.body}`);
   }
   /**
    * Where a cron fires for its citizen: the thread, the channel, or the scope's home it names, else
-   * the conversation of the turn that set it when it wakes its setter, else its home outside projects.
+   * the conversation of the turn that set it when it wakes its setter, a project's channels' in
+   * the society scope included, else its home outside projects.
    */
   async cronConversation(actor, agent, named) {
     const own = actor.name === agent.name;
     if (named.project === void 0 && named.thread_id === void 0 && named.channel === void 0) {
+      if (own && actor.scope === SOCIETY_SCOPE && actor.place !== void 0) {
+        await this.readActiveProject(actor.place);
+        return { scope: SOCIETY_SCOPE, place: actor.place };
+      }
       return own && actor.scope !== void 0 ? this.cronConversation(actor, agent, {
         project: actor.scope,
         thread_id: actor.thread,
@@ -5750,7 +5627,8 @@ ${current.body}`);
       agent: cron.agent,
       project: cron.scope,
       ...cron.thread === void 0 ? {} : { thread: cron.thread },
-      ...cron.channel === void 0 ? {} : { channel: cron.channel }
+      ...cron.channel === void 0 ? {} : { channel: cron.channel },
+      ...cron.place === void 0 ? {} : { place: cron.place }
     };
   }
   async readCronFile(file) {
@@ -5783,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. */
@@ -5822,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?.thread.state !== "open") {
+      throw new BoardError("INVALID_STATE", `proposal ${proposal.id} has no open thread`);
     }
-    if (found === null) {
-      return this.openThreadUnlocked(proposal.proposedBy, this.proposalThreadOpening(proposal));
-    }
-    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) {
@@ -5855,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.
@@ -5961,17 +5767,20 @@ ${current.body}`);
   async openThreadIds(dir, keep) {
     const ids = /* @__PURE__ */ new Set();
     for (const file of await listFiles(dir)) {
-      const doc = await readMarkdown(path6.join(dir, file), ThreadFrontmatterSchema);
+      const doc = await readMarkdown(path7.join(dir, file), ThreadFrontmatterSchema);
       if (doc.data.state === "open" && keep({ ...doc.data, body: doc.body })) {
         ids.add(doc.data.id);
       }
     }
     return ids;
   }
-  /** Refuses to archive a project while a turn runs in it or in a thread its archive closes. */
+  /**
+   * Refuses to archive a project while a turn runs in it, in a citizen's conversation of its
+   * channels in the society scope, or in a thread its archive closes.
+   */
   async assertProjectQuiet(actor, slug) {
     const threads = await this.openThreadIds(this.paths.threads(slug), () => true);
-    this.assertNoTurnCut(actor, `project ${slug} cannot be archived`, (turn) => turn.scope === slug || turn.thread !== void 0 && threads.has(turn.thread));
+    this.assertNoTurnCut(actor, `project ${slug} cannot be archived`, (turn) => turn.scope === slug || turn.place === slug || turn.thread !== void 0 && threads.has(turn.thread));
   }
   async closeThread(actor, input) {
     const args = VerbInputs.close_thread.parse(input);
@@ -6512,7 +6321,8 @@ ${args.summary}`);
             filedFrom: {
               scope: actor.scope,
               ...actor.thread === void 0 ? {} : { thread: actor.thread },
-              ...actor.channel === void 0 ? {} : { channel: actor.channel }
+              ...actor.channel === void 0 ? {} : { channel: actor.channel },
+              ...actor.place === void 0 ? {} : { place: actor.place }
             }
           },
           charter: parsed.data
@@ -6924,19 +6734,20 @@ ${rationale}`}`);
         project: input.project,
         ...input.thread === void 0 ? {} : { thread: input.thread },
         ...input.channel === void 0 ? {} : { channel: input.channel },
+        ...input.place === void 0 ? {} : { place: input.place },
         messages: [...input.messages]
       });
     });
   }
   /**
    * Where a conversation's session ids and last turn are kept: the scope's home, or beside it a
-   * thread's or a channel's, named by `part` as `conversationPart` gives it.
+   * thread's, a channel's, or a project's, named by `part` as `conversationPart` gives it.
    */
   sessionDir(agent, scope, part) {
     return part === void 0 ? this.paths.agentProject(agent, scope) : this.paths.agentConversation(agent, scope, part);
   }
   async readSessions(agent, project, part) {
-    const file = path6.join(this.sessionDir(agent, project, part), "sessions.json");
+    const file = path7.join(this.sessionDir(agent, project, part), "sessions.json");
     return await exists(file) ? readJson(file, SessionsFileSchema) : {};
   }
   /**
@@ -6947,15 +6758,34 @@ ${rationale}`}`);
     await this.mutex.run(async () => {
       const dir = this.sessionDir(agent, project, part);
       await ensureDir(dir);
-      const file = path6.join(dir, "sessions.json");
+      const file = path7.join(dir, "sessions.json");
       const current = await exists(file) ? await readJson(file, SessionsFileSchema) : {};
       const kept = current.runner === void 0 || current.runner === runner ? current : {};
       await writeJson(file, { ...kept, [cli]: sessionId, runner });
     });
   }
-  /** The last turn of one conversation: the scope's home, a channel's, or a thread's. */
+  /**
+   * Drops a conversation's session for a CLI, so its next turn starts a new one, when the record
+   * still names `sessionId`; returns whether it did.
+   */
+  async dropSession(agent, project, cli, sessionId, part) {
+    return this.mutex.run(async () => {
+      const file = path7.join(this.sessionDir(agent, project, part), "sessions.json");
+      if (!await exists(file)) {
+        return false;
+      }
+      const current = await readJson(file, SessionsFileSchema);
+      if (current[cli] !== sessionId) {
+        return false;
+      }
+      const { [cli]: _dropped, ...kept } = current;
+      await writeJson(file, kept);
+      return true;
+    });
+  }
+  /** The last turn of one conversation: the scope's home, a channel's, a project's, or a thread's. */
   async readLastTurn(agent, project, part) {
-    const file = path6.join(this.sessionDir(agent, project, part), "last-turn.json");
+    const file = path7.join(this.sessionDir(agent, project, part), "last-turn.json");
     return await exists(file) ? readJson(file, TurnRecordSchema) : null;
   }
   /** The latest turn a citizen took in a scope, in any of its conversations there. */
@@ -6963,8 +6793,9 @@ ${rationale}`}`);
     let latest = await this.readLastTurn(agent, project);
     const place = this.paths.agentProject(agent, project);
     const parts = [
-      ...await listDirs(path6.join(place, "threads")),
-      ...(await listDirs(path6.join(place, "channels"))).map((name) => `#${name}`)
+      ...await listDirs(path7.join(place, "threads")),
+      ...(await listDirs(path7.join(place, "channels"))).map((name) => `#${name}`),
+      ...(await listDirs(path7.join(place, "places"))).map((name) => `~${name}`)
     ];
     for (const part of parts) {
       const turn = await this.readLastTurn(agent, project, part);
@@ -6985,6 +6816,7 @@ ${rationale}`}`);
         project: parsed.project,
         ...parsed.thread === void 0 ? {} : { thread: parsed.thread },
         ...parsed.channel === void 0 ? {} : { channel: parsed.channel },
+        ...parsed.place === void 0 ? {} : { place: parsed.place },
         trigger: parsed.trigger.kind,
         session: parsed.session,
         runner: parsed.runner
@@ -7014,7 +6846,8 @@ ${rationale}`}`);
           agent: parsed.agent,
           project: parsed.project,
           ...parsed.thread === void 0 ? {} : { thread: parsed.thread },
-          ...parsed.channel === void 0 ? {} : { channel: parsed.channel }
+          ...parsed.channel === void 0 ? {} : { channel: parsed.channel },
+          ...parsed.place === void 0 ? {} : { place: parsed.place }
         });
       }
       await this.events.append(failed ? "turn.failed" : "turn.completed", parsed.agent, {
@@ -7022,6 +6855,7 @@ ${rationale}`}`);
         project: parsed.project,
         ...parsed.thread === void 0 ? {} : { thread: parsed.thread },
         ...parsed.channel === void 0 ? {} : { channel: parsed.channel },
+        ...parsed.place === void 0 ? {} : { place: parsed.place },
         trigger: parsed.trigger.kind,
         session: parsed.session,
         exitReason: parsed.exitReason,
@@ -7031,7 +6865,10 @@ ${rationale}`}`);
         model: parsed.model,
         summary: parsed.status?.summary ?? null,
         needsUserDecision: parsed.status?.needsUserDecision ?? false,
-        error: parsed.error
+        error: parsed.error,
+        ...parsed.resumeFailed === void 0 ? {} : { resumeFailed: parsed.resumeFailed },
+        ...parsed.transient === true ? { transient: true } : {},
+        ...parsed.sessionDropped === true ? { sessionDropped: true } : {}
       });
     });
   }
@@ -7068,6 +6905,20 @@ ${rationale}`}`);
       return task;
     });
   }
+  /**
+   * Posts the board's word on a task's work into the task's thread, such as commits a runner
+   * could not put on its branch: as the board, with every `@name` written as a plain name, so it
+   * wakes nobody and counts toward no heartbeat. Null, posting nothing, once the thread is closed.
+   */
+  async postTaskNotice(taskId, body) {
+    return this.mutex.run(async () => {
+      const found = await this.tryFindThread(taskId);
+      if (found === null || found.thread.state !== "open") {
+        return null;
+      }
+      return this.appendThreadMessage(SYSTEM_ACTOR.name, taskId, withoutMentions(body));
+    });
+  }
   /**
    * Records that a citizen's workspace in a conversation that has ended holds work on no branch, so
    * the scheduler gives the citizen a closing turn there to decide about it. False, recording
@@ -7078,7 +6929,7 @@ ${rationale}`}`);
     const payload = {
       agent: input.agent,
       project: input.scope,
-      ...conversation.kind === "thread" ? { thread: conversation.id } : { channel: conversation.name }
+      ...conversation.kind === "thread" ? { thread: conversation.id } : conversation.kind === "channel" ? { channel: conversation.name } : { place: conversation.project }
     };
     return this.mutex.run(async () => {
       const earlier = (await this.events.readSince(null, Number.MAX_SAFE_INTEGER)).filter((event) => event.type === "workspace.leftovers" && Object.entries(payload).every(([key, value]) => event.payload[key] === value)).length;
@@ -7130,9 +6981,13 @@ ${rationale}`}`);
   }
   /**
    * Whether a conversation with a workspace of its own has ended: a thread closed, a task ended
-   * (for one from before tasks had threads), or a channel archived.
+   * (for one from before tasks had threads), a channel archived, or a project archived, which ends
+   * every citizen's conversation of its channels in the society scope.
    */
   async conversationEnded(conversation) {
+    if (conversation.kind === "place") {
+      return !await this.projectLive(conversation.project);
+    }
     if (conversation.kind === "channel") {
       const place = conversation.scope === SOCIETY_SCOPE ? null : conversation.scope;
       return !await this.channelOpen(channelRef(place, conversation.name));
@@ -7206,11 +7061,11 @@ ${rationale}`}`);
   }
   /** Small named state files under data/state, for cursors the scheduler must keep across restarts. */
   async readState(name, schema, fallback) {
-    const file = path6.join(this.paths.state(), `${name}.json`);
+    const file = path7.join(this.paths.state(), `${name}.json`);
     return await exists(file) ? readJson(file, schema) : fallback;
   }
   async writeState(name, value) {
-    await this.mutex.run(() => writeJson(path6.join(this.paths.state(), `${name}.json`), value));
+    await this.mutex.run(() => writeJson(path7.join(this.paths.state(), `${name}.json`), value));
   }
   /** The project's dashboard, empty at revision 0 when it has none. */
   async readDashboard(slug) {
@@ -7241,7 +7096,7 @@ ${rationale}`}`);
   async listRunners() {
     const runners2 = [];
     for (const file of await listFiles(this.paths.runners())) {
-      runners2.push((await readMarkdown(path6.join(this.paths.runners(), file), RunnerSchema)).data);
+      runners2.push((await readMarkdown(path7.join(this.paths.runners(), file), RunnerSchema)).data);
     }
     return runners2;
   }
@@ -7293,7 +7148,7 @@ ${rationale}`}`);
     return this.runnerTokens.get(hashToken(token)) ?? null;
   }
   runnerTokensFile() {
-    return path6.join(this.paths.state(), "runners.json");
+    return path7.join(this.paths.state(), "runners.json");
   }
   async readRunnerTokens() {
     const file = this.runnerTokensFile();
@@ -7342,26 +7197,26 @@ ${rationale}`}`);
   async listHomeConflicts(agent) {
     const home = this.paths.agent(agent);
     const found = [];
-    const walk = async (dir, prefix) => {
-      for (const entry of await readdir3(dir, { withFileTypes: true }).catch(() => [])) {
+    const walk2 = async (dir, prefix) => {
+      for (const entry of await readdir4(dir, { withFileTypes: true }).catch(() => [])) {
         if (prefix === "" && SKIPPED_IN_HOME.has(entry.name)) {
           continue;
         }
         const relative = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
         if (entry.isDirectory()) {
-          await walk(path6.join(dir, entry.name), relative);
+          await walk2(path7.join(dir, entry.name), relative);
           continue;
         }
         const file = entry.isFile() ? conflictCopyOf(relative) : null;
         if (file !== null) {
-          const since = await this.homes.changedAt(home, relative) ?? (await stat3(path6.join(home, relative)).catch(() => null))?.mtime.toISOString();
+          const since = await this.homes.changedAt(home, relative) ?? (await stat3(path7.join(home, relative)).catch(() => null))?.mtime.toISOString();
           if (since !== void 0) {
             found.push({ path: relative, file, since });
           }
         }
       }
     };
-    await walk(home, "");
+    await walk2(home, "");
     return found.toSorted((a, b) => a.path.localeCompare(b.path));
   }
   /** The newest `limit` changes to an agent's home, newest first; empty while it is no repository. */
@@ -7438,7 +7293,7 @@ ${rationale}`}`);
   async writeTurnRecord(record) {
     const dir = this.sessionDir(record.agent, record.project, conversationPart(record));
     await ensureDir(dir);
-    await writeJson(path6.join(dir, "last-turn.json"), record);
+    await writeJson(path7.join(dir, "last-turn.json"), record);
   }
   // ---------------------------------------------------------------------------------------------
   // Internals
@@ -7557,8 +7412,8 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
   async ensureAgentProject(name, slug) {
     const dir = this.paths.agentProject(name, slug);
     await ensureDir(dir);
-    if (!await exists(path6.join(dir, "sessions.json"))) {
-      await writeJson(path6.join(dir, "sessions.json"), {});
+    if (!await exists(path7.join(dir, "sessions.json"))) {
+      await writeJson(path7.join(dir, "sessions.json"), {});
     }
   }
   /**
@@ -7590,7 +7445,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       const at = turn?.endedAt ?? turn?.startedAt;
       if (turn !== null && at !== void 0 && (lastTurnAt === void 0 || at > lastTurnAt)) {
         lastTurnAt = at;
-        lastTurnOutcome = `${turn.trigger.kind} on ${scope}: ${turn.exitReason ?? "running"}${turn.status === null ? "" : `, ${turn.status.summary.slice(0, 160)}`}`;
+        lastTurnOutcome = `${turn.trigger.kind} on ${scope}${turnConversation(turn)}: ${turn.exitReason ?? "running"}${turn.status === null ? "" : `, ${turn.status.summary.slice(0, 160)}`}`;
         lastModel = turn.model ?? void 0;
       }
     }
@@ -7720,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;
     }
@@ -7788,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 };
       }
@@ -7802,25 +7647,21 @@ 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);
     const file = this.paths.societySkillFile(skill.name);
     const replaced = await exists(file);
     const taken = proposal.skillFiles;
-    const staged = path6.join(this.paths.proposalFiles(proposal.id), "SKILL.md");
-    if (skill.body === void 0 && (taken === void 0 || !await exists(staged))) {
+    const staged = path7.join(this.paths.proposalFiles(proposal.id), "SKILL.md");
+    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,
@@ -7828,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, {
@@ -7836,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.`);
@@ -7873,8 +7714,8 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     const dir = this.paths.proposalFiles(proposal.id);
     await rm2(dir, { recursive: true, force: true });
     for (const entry of taken.files) {
-      const target = path6.join(dir, ...entry.path.split("/"));
-      await ensureDir(path6.dirname(target));
+      const target = path7.join(dir, ...entry.path.split("/"));
+      await ensureDir(path7.dirname(target));
       await writeFile4(target, contents.get(entry.path) ?? Buffer.alloc(0));
       await chmod2(target, entry.executable ? 493 : 420);
     }
@@ -7932,7 +7773,8 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     const where = {
       scope: turn.project,
       ...turn.thread === void 0 ? {} : { thread: turn.thread },
-      ...turn.channel === void 0 ? {} : { channel: turn.channel }
+      ...turn.channel === void 0 ? {} : { channel: turn.channel },
+      ...turn.place === void 0 ? {} : { place: turn.place }
     };
     await this.mutex.run(async () => {
       for (const proposal of await this.listProposals()) {
@@ -7964,16 +7806,25 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       if (!isSafeRelativePath(entry.path)) {
         continue;
       }
-      const bytes = await readFile4(path6.join(dir, ...entry.path.split("/"))).catch(() => null);
-      const text = bytes === null || bytes.includes(0) ? null : bytes.toString("utf8");
+      const bytes = await readFile4(path7.join(dir, ...entry.path.split("/"))).catch(() => null);
       files.push({
         ...entry,
-        text: text === null ? null : text.slice(0, SKILL_TEXT_LIMIT_CHARS),
-        truncated: text !== null && text.length > SKILL_TEXT_LIMIT_CHARS
+        ...bytes === null ? { text: null, truncated: false } : skillFileText(bytes)
       });
     }
     return files;
   }
+  /**
+   * A society skill's folder as it is published, with each file's text, for the skill's view; an
+   * unknown skill, or a folder without a SKILL.md, is not found.
+   */
+  async readSocietySkillFiles(name) {
+    const files = await readSkillFolder(this.paths.societySkill(NameSchema.parse(name)));
+    if (files === null) {
+      throw new BoardError("NOT_FOUND", `the society has no skill ${name}`);
+    }
+    return files;
+  }
   async validateAddAgent(input) {
     if (await exists(this.paths.agentFile(input.name))) {
       throw new BoardError("ALREADY_EXISTS", `agent ${input.name} already exists`);
@@ -8104,7 +7955,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     this.assertNoTurnCut(actor, `${ref} cannot be archived`, (turn) => turn.channel === channel && turn.scope === scope || turn.thread !== void 0 && closing.has(turn.thread));
     const threadsClosed = [];
     for (const file of await listFiles(threads)) {
-      const doc = await readMarkdown(path6.join(threads, file), ThreadFrontmatterSchema);
+      const doc = await readMarkdown(path7.join(threads, file), ThreadFrontmatterSchema);
       if (doc.data.channel !== ref || doc.data.state !== "open") {
         continue;
       }
@@ -8210,7 +8061,8 @@ ${charter.purpose}
     }
   }
   /**
-   * Every member leaves, every open thread on its channels closes, and the project is marked; its
+   * Every member leaves, every open thread on its channels closes, every citizen's conversation of
+   * its channels in the society scope ends with the crons there, and the project is marked; its
    * files, repository, and history stay. The notice is the board's, since the reason is free text
    * a proposer wrote and a board-authored mention would wake whoever it names.
    */
@@ -8235,7 +8087,7 @@ ${charter.purpose}
     const threads = this.paths.threads(slug);
     const threadsClosed = [];
     for (const file of await listFiles(threads)) {
-      const doc = await readMarkdown(path6.join(threads, file), ThreadFrontmatterSchema);
+      const doc = await readMarkdown(path7.join(threads, file), ThreadFrontmatterSchema);
       if (doc.data.state !== "open") {
         continue;
       }
@@ -8253,7 +8105,7 @@ ${charter.purpose}
       });
       threadsClosed.push(doc.data.id);
     }
-    await this.endCronsUnlocked(by, `project ${slug} was archived`, (cron) => cron.scope === slug || cron.thread !== void 0 && threadsClosed.includes(cron.thread));
+    await this.endCronsUnlocked(by, `project ${slug} was archived`, (cron) => cron.scope === slug || cron.place === slug || cron.thread !== void 0 && threadsClosed.includes(cron.thread));
     const project = await this.updateProject(slug, (p) => ({
       ...p,
       members: [],
@@ -8310,10 +8162,10 @@ ${charter.purpose}
         ...project,
         members: project.members.filter((member) => member !== name)
       }));
-      const sessions = path6.join(this.paths.agentProject(name, slug), "sessions.json");
+      const sessions = path7.join(this.paths.agentProject(name, slug), "sessions.json");
       if (await exists(sessions)) {
         const archived = `sessions.archived.${ts.replace(/[:.]/g, "-")}.json`;
-        await rename3(sessions, path6.join(this.paths.agentProject(name, slug), archived));
+        await rename3(sessions, path7.join(this.paths.agentProject(name, slug), archived));
       }
     }
     this.tokenIndex.delete(current.tokenHash);
@@ -8393,6 +8245,17 @@ ${charter.purpose}
       return false;
     }
   }
+  /**
+   * Whether a project exists and is not archived, so citizens' conversations of its channels in
+   * the society scope are still going.
+   */
+  async projectLive(slug) {
+    try {
+      return (await this.readProject(slug)).archived === void 0;
+    } catch {
+      return false;
+    }
+  }
   /**
    * A channel that takes new posts, threads, tasks, and followers: it exists, it is not archived,
    * and its project is not archived.
@@ -8503,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);
     }
@@ -8544,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);
@@ -8643,7 +8506,7 @@ ${charter.purpose}
       if (since !== null && id <= since || upto !== void 0 && id > upto) {
         continue;
       }
-      const doc = await readMarkdown(path6.join(dir, file), MessageFrontmatterSchema);
+      const doc = await readMarkdown(path7.join(dir, file), MessageFrontmatterSchema);
       messages.push({ ...doc.data, body: doc.body });
     }
     return messages;
@@ -8739,11 +8602,21 @@ function besideFields(beside) {
   if (beside === void 0) {
     return {};
   }
-  return "thread" in beside ? { thread: beside.thread } : { channel: beside.channel };
+  if ("thread" in beside) {
+    return { thread: beside.thread };
+  }
+  return "channel" in beside ? { channel: beside.channel } : { place: beside.place };
+}
+function namedIn(dispatch) {
+  return {
+    ...dispatch.thread === void 0 ? {} : { thread: dispatch.thread.id },
+    ...dispatch.channel === void 0 ? {} : { channel: dispatch.channel },
+    ...dispatch.place === void 0 ? {} : { place: dispatch.place }
+  };
 }
 function conversationKey2(agent, scope, beside) {
   const fields = besideFields(beside);
-  return sessionKey(agent, scope, conversationPart({ thread: fields.thread?.id, channel: fields.channel }));
+  return sessionKey(agent, scope, conversationPart({ thread: fields.thread?.id, channel: fields.channel, place: fields.place }));
 }
 var DEFAULT_TIMINGS = Object.freeze({
   pollMs: 1e3,
@@ -8754,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(),
@@ -8770,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 });
     }
   }
@@ -8805,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({}),
@@ -8829,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";
@@ -8885,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: {}
@@ -9097,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": {
@@ -9215,6 +9111,21 @@ var Scheduler = class {
         }
         return;
       }
+      case "project.archived": {
+        const slug = stringOf(payload["slug"]);
+        if (slug === null) {
+          return;
+        }
+        this.sweep({ kind: "place", project: slug });
+        for (const [key, item] of this.pending) {
+          const { dispatch } = item;
+          if (dispatch.place === slug) {
+            this.pending.delete(key);
+            this.log.info({ agent: dispatch.agent, project: dispatch.project, place: slug }, "dropping project wake, the project is archived");
+          }
+        }
+        return;
+      }
       case "agent.left": {
         const name = stringOf(payload["name"]);
         const project = stringOf(payload["project"]);
@@ -9245,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);
@@ -9516,11 +9427,12 @@ var Scheduler = class {
     const scope = stringOf(payload["project"]);
     const thread = stringOf(payload["thread"]);
     const channel = stringOf(payload["channel"]);
+    const place = stringOf(payload["place"]);
     const agent = name === null ? null : await this.tryReadAgent(name);
     if (agent === null || scope === null) {
       return;
     }
-    const beside = thread !== null ? { thread: await this.conversationOf(thread, scope) } : channel !== null ? { channel } : null;
+    const beside = thread !== null ? { thread: await this.conversationOf(thread, scope) } : channel !== null ? { channel } : place !== null ? { place } : null;
     if (beside === null) {
       return;
     }
@@ -9565,7 +9477,7 @@ var Scheduler = class {
     }
     return {
       scope,
-      beside: conversation.kind === "thread" ? { thread: await this.conversationOf(conversation.id, scope) } : { channel: conversation.name }
+      beside: conversation.kind === "thread" ? { thread: await this.conversationOf(conversation.id, scope) } : conversation.kind === "channel" ? { channel: conversation.name } : { place: conversation.project }
     };
   }
   /**
@@ -9583,14 +9495,23 @@ var Scheduler = class {
   }
   /**
    * The conversation a post wakes a citizen in, for a turn in `scope`: its thread's, else its
-   * channel's when that is a channel of the scope other than general, else the scope's home.
+   * channel's when that is a channel of the scope other than general, else, for a turn in the
+   * society scope, its project's when it is a project's channel, general included, else the
+   * scope's home.
    */
   async postedIn(scope, channel, threadId) {
     if (threadId !== void 0) {
       return { thread: await this.conversationOf(threadId, scope) };
     }
-    const name = channel === null ? void 0 : channelConversation(scope, channel);
-    return name === void 0 ? void 0 : { channel: name };
+    if (channel === null) {
+      return void 0;
+    }
+    const name = channelConversation(scope, channel);
+    if (name !== void 0) {
+      return { channel: name };
+    }
+    const place = placeConversation(scope, channel);
+    return place === void 0 ? void 0 : { place };
   }
   async tryReadAgent(name) {
     try {
@@ -9732,7 +9653,7 @@ var Scheduler = class {
         };
         for (const entry of unread) {
           if (entry.scope === project) {
-            const beside = entry.thread !== null ? { thread: await this.conversationOf(entry.thread, project) } : entry.channel !== null ? { channel: entry.channel } : void 0;
+            const beside = entry.thread !== null ? { thread: await this.conversationOf(entry.thread, project) } : entry.channel !== null ? { channel: entry.channel } : entry.place !== null ? { place: entry.place } : void 0;
             reasonsIn(beside).digestSize += entry.count;
           }
         }
@@ -9819,7 +9740,10 @@ var Scheduler = class {
     if (cron.thread !== void 0) {
       return { thread: await this.conversationOf(cron.thread, cron.scope) };
     }
-    return cron.channel === void 0 ? void 0 : { channel: cron.channel };
+    if (cron.channel !== void 0) {
+      return { channel: cron.channel };
+    }
+    return cron.place === void 0 ? void 0 : { place: cron.place };
   }
   /** Whether a cron's wake waits in the queue or its turn is running. */
   cronQueuedOrRunning(id) {
@@ -9943,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 = [];
@@ -10204,8 +10159,7 @@ var Scheduler = class {
       const attempt = steer({
         agent: dispatch.agent,
         project: dispatch.project,
-        ...dispatch.thread === void 0 ? {} : { thread: dispatch.thread.id },
-        ...dispatch.channel === void 0 ? {} : { channel: dispatch.channel }
+        ...namedIn(dispatch)
       }).then((outcome) => {
         const current = this.pending.get(key);
         if (outcome !== "busy" && current !== void 0) {
@@ -10226,7 +10180,7 @@ var Scheduler = class {
       return false;
     }
     const { dispatch } = item;
-    const cursor = await this.board.digestCursor(dispatch.agent, dispatch.project, conversationPart({ thread: dispatch.thread?.id, channel: dispatch.channel }));
+    const cursor = await this.board.digestCursor(dispatch.agent, dispatch.project, conversationPart(namedIn(dispatch)));
     return cursor !== null && cursor >= item.newestMessage;
   }
   async dispatchReady(now) {
@@ -10263,6 +10217,7 @@ var Scheduler = class {
         project: dispatch.project,
         thread: dispatch.thread?.id,
         channel: dispatch.channel,
+        place: dispatch.place,
         trigger: dispatch.trigger.kind
       }, "dispatching turn");
       const crons = dispatch.crons ?? [];
@@ -10278,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 {
@@ -10296,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;
@@ -10379,9 +10377,9 @@ import { randomUUID } from "node:crypto";
 
 // packages/turn-host/dist/render.js
 var TURN_CONTRACT = [
-  "- Every turn belongs to one conversation, named at the top of your prompt: your home conversation in a project or the society, for its general channel and for work tied to no other channel and no thread; the conversation of one other channel of the place, a workstream such as a release; or the conversation of one thread you take part in, a task's, a proposal's, or a topic's. Each has its own session and its own turns, which may run while this one does. The prompt carries this conversation only: in a thread, its new messages, or the whole thread when the conversation is new, and in a task's thread the task and its stage; in a channel's or at home, that channel's or general's messages that concern you. Read anything else you need with get_task, search, and the board's files, and leave other channels', other threads', and other projects' work to their own turns.",
+  "- Every turn belongs to one conversation, named at the top of your prompt: your home conversation in a project or the society, for its general channel and for work tied to no other channel and no thread; the conversation of one other channel of the place, a workstream such as a release; outside projects, the conversation of one project's channels, general and its workstreams together, for posts there that ask something of you while you are not a member; or the conversation of one thread you take part in, a task's, a proposal's, or a topic's. Each has its own session and its own turns, which may run while this one does. The prompt carries this conversation only: in a thread, its new messages, or the whole thread when the conversation is new, and in a task's thread the task and its stage; in a channel's, a project's, or at home, that channel's, that project's channels', or general's messages that concern you. Read anything else you need with get_task, search, and the board's files, and leave other channels', other threads', and other projects' work to their own turns.",
   "- Act through the board tools (the `board` MCP server). Holding a stage is a lease; every turn that touches the task renews it.",
-  "- Work only inside your worktree. In a task's conversation it is a worktree of its own on the task's branch `task/<id>`: commit your work there. After each turn the runner commits what you left on the branch and lets it go for the next holder. Your home worktree is on your own branch, `agent/<name>`, for work tied to no task; nothing lands from it by itself. In a proposal's, a topic's, or a channel's conversation it is a worktree of its own, detached at the project's default branch, which goes when the thread closes or the channel is archived, so work that should last goes on a task's branch. Before each turn the runner fetches the project's remote and brings what holds no work of yours up to the default branch: your own branch when it has no commits of its own, a task's branch nobody has worked on, and a detached worktree with nothing uncommitted; what it leaves where it is, and why, is under Your workspace in the prompt. It never merges or commits for you.",
+  "- Work only inside your worktree. In a task's conversation it is a worktree of its own on the task's branch `task/<id>`: commit your work there. The branch is checked out in one worktree at a time and kept for the turns of whoever holds the task's stage, so a turn of anyone else there, or one that starts while another turn has the branch, works detached at its tip, which Your workspace then says; its commits go on the branch by a fast-forward when a turn in the task ends with the branch free, and the task's thread is told of commits that no longer build on its tip. After each turn the runner commits what you left on the branch and lets it go for the next holder. Your home worktree is on your own branch, `agent/<name>`, for work tied to no task; nothing lands from it by itself. In a proposal's, a topic's, or a channel's conversation it is a worktree of its own, detached at the project's default branch, which goes when the thread closes or the channel is archived, so work that should last goes on a task's branch. Before each turn the runner fetches the project's remote and brings what holds no work of yours up to the default branch: your own branch when it has no commits of its own, a task's branch nobody has worked on, and a detached worktree with nothing uncommitted; what it leaves where it is, and why, is under Your workspace in the prompt. It never merges or commits for you.",
   "- Posts that would wake this conversation may arrive while you work, delivered into the turn under a heading that says so and formatted like the digest. They are part of this turn: act on them now, after the step in hand, or not at all, as with the digest. The user may also stop a turn; the next turn is told.",
   "- Silence is allowed. If the digest needs no reply, post nothing.",
   "- To come back to something later, set a cron with create_cron: a note on what to do then, and a five-field cron expression or one time with at. It wakes you in this conversation unless you name another, at most every fifteen minutes, and every fire is a paid turn, so end a cron with remove_cron once it has done its job. Never wait by holding a stage, sleeping, or leaving a process running: a turn's board token ends with the turn, so nothing it leaves behind can act on the board. The society's crons are under society/crons/ in the board projection.",
@@ -10414,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."
@@ -10454,7 +10452,7 @@ function renderInstructions(input) {
   if (norms.length > 0) {
     sections.push("", "## Society norms", "", norms);
   }
-  sections.push("", "## Core memory", "", memory.length === 0 ? "(empty)" : memory, "", "## Skills", "", ...renderSkillsIndex(input.skills ?? []), "", "## Where things are", "", `- Your home directory: ${input.homeDir}. memory/core.md is loaded every turn; memory/<topic>.md is your archive; skills/<name>/SKILL.md are your skills; projects/<slug>/notes.md are your notes. You may read and write all of it, and the board's search covers your archive and skills for you alone. The runner keeps it in git and shares it with the board after every turn, so whatever machine your next turn runs on has it; leave git there to the runner. Files over ${HOME_FILE_LIMIT_BYTES / (1024 * 1024)} MB are not kept.`, `- ${HOME_SCRATCH}/ in your home is your working folder in turns outside any project, and a thread's or a channel's conversation there works in a folder of its own inside it, which goes when the thread closes or the channel is archived: none of it is kept or shared, so put downloads, environments, and other working files there, and keep the rest of your home for what you mean to remember.`, `- The board projection: ${input.boardDir} (read-only markdown: society and project channels, tasks, threads; shared knowledge under projects/<slug>/knowledge/ and society/knowledge/; the society's skills under society/skills/; each project's dashboard, the status page the user reads on its view, at projects/<slug>/dashboard.md, which its members change with update_dashboard). Search it with your file tools; act through the board tools.`, "", "## Turn contract", "", TURN_CONTRACT, "", "## Planning", "", PLANNING, "", "## Governance", "", GOVERNANCE);
+  sections.push("", "## Core memory", "", memory.length === 0 ? "(empty)" : memory, "", "## Skills", "", ...renderSkillsIndex(input.skills ?? []), "", "## Where things are", "", `- Your home directory: ${input.homeDir}. memory/core.md is loaded every turn; memory/<topic>.md is your archive; skills/<name>/SKILL.md are your skills; projects/<slug>/notes.md are your notes. You may read and write all of it, and the board's search covers your archive and skills for you alone. The runner keeps it in git and shares it with the board after every turn, so whatever machine your next turn runs on has it; leave git there to the runner. Files over ${HOME_FILE_LIMIT_BYTES / (1024 * 1024)} MB are not kept.`, `- ${HOME_SCRATCH}/ in your home is your working folder in turns outside any project, and a thread's, a channel's, or a project's channels' conversation there works in a folder of its own inside it, which goes when the thread closes or the channel or the project is archived: none of it is kept or shared, so put downloads, environments, and other working files there, and keep the rest of your home for what you mean to remember.`, `- The board projection: ${input.boardDir} (read-only markdown: society and project channels, tasks, threads; shared knowledge under projects/<slug>/knowledge/ and society/knowledge/; the society's skills under society/skills/; each project's dashboard, the status page the user reads on its view, at projects/<slug>/dashboard.md, which its members change with update_dashboard). Search it with your file tools; act through the board tools.`, "", "## Turn contract", "", TURN_CONTRACT, "", "## Planning", "", PLANNING, "", "## Governance", "", GOVERNANCE);
   if (input.onboarding !== void 0) {
     sections.push("", "## First turn", "", renderOnboardingPreamble(input.onboarding));
   }
@@ -10608,7 +10606,7 @@ function buildTurnPrompt(input) {
     lines.push("Operations signals arrived; they are listed under Operations signals below. Decide whether a proposal is warranted, and stay silent if not.");
   }
   if (dispatch.trigger.kind === "stage") {
-    lines.push("A stage is waiting for you: claim it with claim_task unless you hold it already, do the work in your worktree, which is on the task's branch, commit there, then advance_task. If the plan no longer fits, reshape it with plan_task.");
+    lines.push("A stage is waiting for you: claim it with claim_task unless you hold it already, do the work in your worktree, which is on the task's branch unless Your workspace says otherwise, commit there, then advance_task. If the plan no longer fits, reshape it with plan_task.");
   }
   if (dispatch.trigger.kind === "task_done") {
     lines.push("A task you created is done. Tell whoever asked for it, if anyone did.");
@@ -10627,8 +10625,11 @@ function buildTurnPrompt(input) {
   if (conversation === null && dispatch.channel !== void 0) {
     const ref = channelRef(dispatch.project === SOCIETY_SCOPE ? null : dispatch.project, dispatch.channel);
     lines.push(`This turn is in your conversation of ${ref}, a workstream with turns of its own: its posts, and the work it asks for. Your home conversation for ${dispatch.project} carries its general channel, and each other channel and each thread you take part in is a conversation of its own; read one when you need it, and leave its work to its turn. Post here with post_message and channel ${ref}.`);
+  } else if (conversation === null && dispatch.place !== void 0) {
+    lines.push(`This turn is in your conversation of project ${dispatch.place}'s channels, from outside the project: the posts in its general and its other channels that concern you, and the work they ask for. Your home conversation for ${dispatch.project} carries its general channel, and each other project's channels, each other channel, and each thread you take part in is a conversation of its own with turns of its own; read one when you need it, and leave its work to its turn. Answer in the channel a post came from with post_message.`);
   } else if (conversation === null) {
-    lines.push(`This turn is in your home conversation for ${dispatch.project}: its general channel, and work tied to no other channel and no thread. Each other channel, a workstream, and each thread you take part in, a task's, a proposal's, or a topic's, is a conversation of its own with turns of its own; read one when you need it, and leave its work to its turn.`);
+    const besides = dispatch.project === SOCIETY_SCOPE ? "Each other channel, each project's channels you are asked in from outside the project, and each thread you take part in, a task's, a proposal's, or a topic's," : "Each other channel, a workstream, and each thread you take part in, a task's, a proposal's, or a topic's,";
+    lines.push(`This turn is in your home conversation for ${dispatch.project}: its general channel, and work tied to no other channel and no thread. ${besides} is a conversation of its own with turns of its own; read one when you need it, and leave its work to its turn.`);
   } else {
     const { thread, task } = conversation;
     const about = thread.subject === void 0 ? "a topic" : `${thread.subject.kind} ${thread.subject.id}`;
@@ -10663,7 +10664,9 @@ function buildTurnPrompt(input) {
     lines.push("", "## The user stopped your previous turn", "", `It was ended on purpose at ${last.endedAt ?? "its end"}, not by a failure. Do not pick its work up again unless this turn asks for it. The worktree may hold uncommitted changes; run git status before doing anything else.`);
   }
   if (last !== null && (last.exitReason === "error" || last.exitReason === "timeout")) {
-    lines.push("", "## Your previous turn did not finish", "", `It ended with ${last.exitReason}${last.error === null ? "" : `: ${last.error}`}.`, "The worktree may hold uncommitted changes. Run git status before doing anything else.");
+    lines.push("", "## Your previous turn did not finish", "", `It ended with ${last.exitReason}${last.error === null ? "" : `: ${last.error}`}.`, ...last.sessionDropped === true ? [
+      "Its CLI could not resume this conversation's session, so the session was dropped and this turn starts a new one: nothing of your earlier turns here carries over but what is on the board and in your home."
+    ] : [], "The worktree may hold uncommitted changes. Run git status before doing anything else.");
   }
   const society = input.societyView;
   if (society !== void 0 && society !== null) {
@@ -10719,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));
       }
@@ -10759,6 +10762,13 @@ function capitalized(text) {
 }
 
 // packages/turn-host/dist/host.js
+function conversationOfJob(job) {
+  return {
+    ...job.thread === void 0 ? {} : { thread: job.thread },
+    ...job.channel === void 0 ? {} : { channel: job.channel },
+    ...job.place === void 0 ? {} : { place: job.place }
+  };
+}
 var SILENT = { info() {
 }, warn() {
 }, error() {
@@ -10769,7 +10779,50 @@ var DEFAULT_RESIDENT_IDLE_MS = 10 * 6e4;
 var LEASE_RENEW_MS = 10 * 6e4;
 var USER_POST_TRIGGER2 = "user_post";
 var OPS_TRIGGER2 = "ops_event";
+var RESUME_RETRIES = 3;
+function stuckNotice(stuck) {
+  const more = stuck.total - stuck.commits.length;
+  const commits = `${stuck.commits.map((commit) => `\`${commit}\``).join(", ")}${more > 0 ? `, and ${more} more` : ""}`;
+  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;
@@ -10813,13 +10866,15 @@ var TurnHost = class {
     const actor = { name: agent.name, role: agent.role };
     const thread = dispatch.thread;
     const channel = thread === void 0 ? dispatch.channel : void 0;
-    const part = conversationPart({ thread: thread?.id, channel });
+    const place = thread === void 0 && channel === void 0 && dispatch.project === SOCIETY_SCOPE ? dispatch.place : void 0;
+    const part = conversationPart({ thread: thread?.id, channel, place });
     const startedAt = this.now().toISOString();
     const base = {
       agent: agent.name,
       project: dispatch.project,
       ...thread === void 0 ? {} : { thread: thread.id },
       ...channel === void 0 ? {} : { channel },
+      ...place === void 0 ? {} : { place },
       runner: runner.name,
       cli: agent.cli,
       session: null,
@@ -10844,23 +10899,25 @@ var TurnHost = class {
     const charter = await this.board.readRole(agent.role);
     const societyScope = dispatch.project === SOCIETY_SCOPE;
     const taskId = thread?.task === true ? thread.id : void 0;
+    const task = taskId === void 0 ? null : await this.board.findTask(taskId).then((found) => found.task).catch(() => null);
     const project = societyScope ? null : await this.board.readProject(dispatch.project);
-    const workspace = await this.workspaceOf(project, thread, channel);
+    const workspace = await this.workspaceOf(project, thread, channel, place, task);
     const sessions = await this.board.readSessions(agent.name, dispatch.project, part);
     const recorded = sessions.runner === runner.name ? sessions[agent.cli] : void 0;
     const newSession = recorded === void 0;
     const lastTurn = await this.board.readLastTurn(agent.name, dispatch.project, part);
     const costSoFarUsd = !newSession && lastTurn?.session === recorded ? lastTurn.sessionCostUsd ?? lastTurn.costUsd : 0;
+    const resumeRetries = !newSession && lastTurn?.session === recorded && lastTurn.resumeFailed === "retry" ? lastTurn.resumeRetries ?? 1 : 0;
     const digest = await this.board.readDigest({
       ...actor,
       scope: dispatch.project,
       ...thread === void 0 ? {} : { thread: thread.id },
-      ...channel === void 0 ? {} : { channel }
+      ...channel === void 0 ? {} : { channel },
+      ...place === void 0 ? {} : { place }
     }, { advance: false, limit: thread === void 0 ? 50 : 100 });
     const threadSoFar = thread !== void 0 && newSession ? (await this.board.listThread(thread.id).catch(() => [])).slice(-100) : null;
     const messages = threadSoFar ?? digest.messages;
     const cursorAfter = threadSoFar?.at(-1)?.id ?? digest.cursor;
-    const task = taskId === void 0 ? null : await this.board.findTask(taskId).then((found) => found.task).catch(() => null);
     const held = task === null ? [] : (await this.board.heldClaims(agent.name)).filter((each) => each.id === task.id);
     const onboarding = dispatch.onboarding || newSession && part === void 0 ? {
       agentName: agent.name,
@@ -10903,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 ?? []))) {
@@ -10919,7 +10976,7 @@ var TurnHost = class {
       fresh: threadSoFar !== null,
       ...threadRecord.state === "closed" ? { replyIn: await this.replyIn(threadRecord) } : {}
     };
-    const ending = dispatch.trigger.kind === "closing" ? await this.endingOf(dispatch.project, threadRecord, task, channel) : null;
+    const ending = dispatch.trigger.kind === "closing" ? await this.endingOf(dispatch.project, threadRecord, task, channel, place) : null;
     const society = await this.board.society();
     const crons = [];
     for (const id of dispatch.crons ?? []) {
@@ -10968,6 +11025,7 @@ var TurnHost = class {
       scope: dispatch.project,
       ...thread === void 0 ? {} : { thread: thread.id },
       ...channel === void 0 ? {} : { channel },
+      ...place === void 0 ? {} : { place },
       session: recorded ?? null,
       costSoFarUsd,
       instructions,
@@ -10994,6 +11052,7 @@ var TurnHost = class {
       stopRequestedBy: null,
       held: held.map((each) => each.id),
       costSoFarUsd,
+      resumeRetries,
       configuredModel: agent.model ?? null,
       transcript: [],
       coldToken: residentKey === null ? token : null,
@@ -11007,6 +11066,7 @@ var TurnHost = class {
       project: dispatch.project,
       thread: thread?.id,
       channel,
+      place,
       runner: runner.name,
       session: recorded,
       newSession,
@@ -11043,8 +11103,7 @@ var TurnHost = class {
             turnId,
             agent: turn.job.agent,
             project: turn.job.scope,
-            thread: turn.job.thread,
-            channel: turn.job.channel,
+            ...conversationOfJob(turn.job),
             messages: sent.messages
           }).catch((error) => {
             this.log.warn({ turnId, error: String(error) }, "could not record a steer");
@@ -11052,17 +11111,14 @@ var TurnHost = class {
         }
       }
       turn.transcript.push(entry);
-      this.onEvent?.(turn.job.agent, turn.job.scope, entry.event, {
-        thread: turn.job.thread,
-        channel: turn.job.channel
-      });
+      this.onEvent?.(turn.job.agent, turn.job.scope, entry.event, conversationOfJob(turn.job));
     }
   }
   /** The turn in flight in a conversation, if any. */
   turnIn(agent, scope, conversation = {}) {
     for (const turn of this.open.values()) {
       const { job } = turn;
-      if (job.agent === agent && job.scope === scope && job.thread === conversation.thread && job.channel === conversation.channel) {
+      if (job.agent === agent && job.scope === scope && job.thread === conversation.thread && job.channel === conversation.channel && job.place === conversation.place) {
         return { turnId: job.turnId, runner: turn.runner, cli: job.cli };
       }
     }
@@ -11073,8 +11129,7 @@ var TurnHost = class {
     return [...this.open.values()].map(({ job }) => ({
       agent: job.agent,
       scope: job.scope,
-      ...job.thread === void 0 ? {} : { thread: job.thread },
-      ...job.channel === void 0 ? {} : { channel: job.channel }
+      ...conversationOfJob(job)
     }));
   }
   /** The turns in flight, for the interface: their conversations and where a mention reaches them. */
@@ -11083,8 +11138,7 @@ var TurnHost = class {
       turnId: turn.job.turnId,
       agent: turn.job.agent,
       scope: turn.job.scope,
-      ...turn.job.thread === void 0 ? {} : { thread: turn.job.thread },
-      ...turn.job.channel === void 0 ? {} : { channel: turn.job.channel },
+      ...conversationOfJob(turn.job),
       cli: turn.job.cli,
       ...turn.record.trigger.channel === void 0 ? {} : { askedIn: turn.record.trigger.channel },
       runner: turn.runner
@@ -11104,12 +11158,7 @@ var TurnHost = class {
       return "busy";
     }
     const { job } = turn;
-    const digest = await this.board.readDigest({
-      ...turn.actor,
-      scope: job.scope,
-      ...job.thread === void 0 ? {} : { thread: job.thread },
-      ...job.channel === void 0 ? {} : { channel: job.channel }
-    }, {
+    const digest = await this.board.readDigest({ ...turn.actor, scope: job.scope, ...conversationOfJob(job) }, {
       ...turn.delivered === null ? {} : { since_cursor: turn.delivered },
       advance: false,
       limit: 50
@@ -11169,6 +11218,8 @@ var TurnHost = class {
     }
     const { job } = turn;
     const part = conversationPart(job);
+    const resumeRetries = outcome.resumeFailed === "retry" ? turn.resumeRetries + 1 : void 0;
+    const dropSession = job.session !== null && (outcome.resumeFailed === "lost" || (resumeRetries ?? 0) >= RESUME_RETRIES);
     const finished = {
       ...turn.record,
       session: outcome.session,
@@ -11182,20 +11233,36 @@ var TurnHost = class {
       toolCalls: turn.transcript.filter((entry) => entry.event.type === "tool_call").length,
       model: outcome.model ?? turn.configuredModel,
       ...outcome.work === null ? {} : { work: outcome.work },
-      ...outcome.exitReason === "stopped" ? { stoppedBy: turn.stopRequestedBy ?? USER_NAME } : {}
+      ...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 } : {}
     };
     const ended = await this.conversationEnded(job);
     const closing = turn.record.trigger.kind === "closing";
     const decided = closing && outcome.exitReason !== "error" && outcome.exitReason !== "timeout";
     const recorded = await this.recorded(turn, async () => {
-      if (outcome.session !== job.session) {
+      if (dropSession && job.session !== null) {
+        await this.board.dropSession(job.agent, job.scope, job.cli, job.session, part);
+        this.log.warn({
+          agent: job.agent,
+          project: job.scope,
+          thread: job.thread,
+          channel: job.channel,
+          place: job.place,
+          session: job.session,
+          resumeFailed: outcome.resumeFailed,
+          resumeRetries
+        }, "dropped a session its CLI could not resume");
+      } else if (outcome.session !== null && outcome.session !== job.session) {
         await this.board.writeSession(job.agent, job.scope, job.cli, outcome.session, turn.runner, part);
       }
       if (outcome.exitReason === "completed" || outcome.exitReason === "blocked" || outcome.exitReason === "stopped") {
         await this.board.setDigestCursor(job.agent, job.scope, turn.delivered, part);
         await this.renewLeases(turn.actor, turn.held);
         if (outcome.status?.needsUserDecision === true) {
-          await this.askUser(turn.actor, job, turn.record.startedAt, outcome.status.summary);
+          await this.askUser(turn.actor, job, turn.record.trigger.channel, turn.record.startedAt, outcome.status.summary);
         }
       }
       await this.board.finishTurn(finished, turn.transcript);
@@ -11207,7 +11274,7 @@ var TurnHost = class {
           conversation
         });
         if (!again) {
-          const where = conversation.kind === "thread" ? `thread ${conversation.id}` : `channel ${conversation.name}`;
+          const where = conversation.kind === "thread" ? `thread ${conversation.id}` : conversation.kind === "channel" ? `channel ${conversation.name}` : `project ${conversation.project}'s channels`;
           await this.board.publishSignal({
             kind: "stuck_workspace",
             key: `stuck_workspace:${job.agent}:${job.scope}:${conversationPart(job) ?? ""}`,
@@ -11224,12 +11291,18 @@ var TurnHost = class {
         this.log.warn({ runner: turn.runner, cli: job.cli, error: String(error) }, "could not record a quota");
       });
     }
+    for (const stuck of outcome.stuck ?? []) {
+      await this.board.postTaskNotice(stuck.branch.slice("task/".length), stuckNotice(stuck)).catch((error) => {
+        this.log.warn({ branch: stuck.branch, agent: stuck.agent, error: String(error) }, "could not tell a task's thread of commits its branch cannot take");
+      });
+    }
     if (recorded) {
       this.log.info({
         agent: job.agent,
         project: job.scope,
         thread: job.thread,
         channel: job.channel,
+        place: job.place,
         exitReason: finished.exitReason
       }, "turn finished");
       await this.takeSkillFiles(finished);
@@ -11296,6 +11369,7 @@ var TurnHost = class {
       project: dispatch.project,
       ...dispatch.thread === void 0 ? {} : { thread: dispatch.thread.id },
       ...dispatch.thread !== void 0 || dispatch.channel === void 0 ? {} : { channel: dispatch.channel },
+      ...dispatch.thread !== void 0 || dispatch.channel !== void 0 || dispatch.project !== SOCIETY_SCOPE || dispatch.place === void 0 ? {} : { place: dispatch.place },
       runner,
       cli: agent?.cli ?? null,
       session: null,
@@ -11342,24 +11416,37 @@ var TurnHost = class {
     return token;
   }
   /**
-   * Where a conversation works: a task's on its branch, any other thread's and a channel's in a
+   * 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
    * place of its own, and the home in the citizen's own.
    */
-  async workspaceOf(project, thread, channel) {
+  async workspaceOf(project, thread, channel, place, task) {
     const own = thread !== void 0 ? thread.task ? {} : { thread: thread.id } : channel === void 0 ? {} : { channel };
     if (project === null) {
-      return { kind: "home", ...own };
+      return { kind: "home", ...own, ...place === void 0 ? {} : { place } };
     }
     const repo = projectRepo(project);
     if (thread?.task === true) {
-      return { kind: "task", repo, taskId: thread.id };
+      const holder = task?.status === "claimed" && task.claimedBy !== void 0 && task.claimedBy !== USER_NAME && (task.leaseExpiresAt === void 0 || new Date(task.leaseExpiresAt).getTime() > this.now().getTime()) ? task.claimedBy : void 0;
+      return { kind: "task", repo, taskId: thread.id, ...holder === void 0 ? {} : { holder } };
     }
-    const branches = (await this.board.listTasks(project.slug)).filter((task) => task.status === "open" || task.status === "claimed").map((task) => `task/${task.id}`);
+    const branches = (await this.board.listTasks(project.slug)).filter((each) => each.status === "open" || each.status === "claimed").map((each) => `task/${each.id}`);
     return { kind: "project", repo, branches, ...own };
   }
   /**
-   * Whether a thread conversation's task or thread has ended, or a channel conversation's channel
-   * was archived, which frees its workspace.
+   * Whether a thread conversation's task or thread has ended, a channel conversation's channel was
+   * archived, or a project conversation's project was, which frees its workspace.
    */
   async conversationEnded(job) {
     const conversation = workspaceConversationOf(job);
@@ -11373,14 +11460,14 @@ var TurnHost = class {
    * How a closing turn's conversation ended, and where its citizen asks someone else to take over
    * work that is not its own: the thread's channel while it is open, else the place's general.
    */
-  async endingOf(scope, thread, task, channel) {
+  async endingOf(scope, thread, task, channel, project) {
     const place = scope === SOCIETY_SCOPE ? null : scope;
     if (thread !== void 0) {
       const closed = `the thread "${thread.title}" on ${thread.channel} was closed${thread.closedBy === void 0 ? "" : ` by ${thread.closedBy}`}${task === null ? "" : `, its task ${task.status}`}`;
       return { how: closed, askIn: await this.replyIn(thread) };
     }
     if (channel === void 0) {
-      return null;
+      return project === void 0 ? null : { how: `project ${project} was archived`, askIn: channelRef(place, "general") };
     }
     const ref = channelRef(place, channel);
     const archived = (await this.board.listChannels()).find((each) => each.ref === ref)?.archived;
@@ -11394,13 +11481,15 @@ var TurnHost = class {
    * the user, which is what puts it before them. One that mentioned the user nowhere asks in its
    * own thread when it was in one that is still open, so the answer comes back to the same
    * conversation, and otherwise in a thread of its own on its conversation's channel, or its scope's
-   * general for the home, opened as the citizen with its summary. One that proposed something the
-   * user decides has put its decision before the user already, where deciding it clears it; a
-   * mention would stay until the user posted beside it.
+   * general for the home, opened as the citizen with its summary; a project's conversation in the
+   * society scope asks on the channel of the project its wake came from, else the project's general.
+   * One that proposed something the user decides has put its decision before the user already,
+   * where deciding it clears it; a mention would stay until the user posted beside it.
    */
-  async askUser(actor, job, since, summary) {
+  async askUser(actor, job, askedIn, since, summary) {
     const threadId = job.thread;
     const place = job.scope === SOCIETY_SCOPE ? null : job.scope;
+    const channel = job.place === void 0 ? channelRef(place, job.channel ?? "general") : askedIn !== void 0 && parseChannelRef(askedIn).project === job.place ? askedIn : channelRef(job.place, "general");
     try {
       if (await this.board.hasMentioned(actor.name, USER_NAME, since)) {
         return;
@@ -11418,7 +11507,7 @@ var TurnHost = class {
         return;
       }
       const thread = await this.board.openThread(actor, {
-        channel: channelRef(place, job.channel ?? "general"),
+        channel,
         title: `${actor.name} asks for a decision: ${summary}`.slice(0, 200)
       });
       await this.board.postMessage(actor, {
@@ -11734,7 +11823,8 @@ var RunnerHub = class {
   async steer(conversation) {
     const turn = this.host.turnIn(conversation.agent, conversation.project, {
       thread: conversation.thread,
-      channel: conversation.channel
+      channel: conversation.channel,
+      place: conversation.place
     });
     const seat = turn === null ? void 0 : this.seats.get(turn.runner);
     if (turn === null || seat === void 0 || seat.send === null) {
@@ -11951,11 +12041,11 @@ var RunnerHub = class {
    * NOT_FOUND when the project has no runner yet or the branch or the path does not exist, and
    * `RunnerAwayError` while its runner is away.
    */
-  async readBranch(project, branch, path10) {
+  async readBranch(project, branch, path11) {
     const { seat, repo } = await this.projectSeat(project, "branchReads", "read files");
-    const file = BranchFileSchema.nullable().parse(await this.request(seat, (request) => ({ type: "file", request, read: { repo, branch, path: path10 } }), FILE_TIMEOUT_MS));
+    const file = BranchFileSchema.nullable().parse(await this.request(seat, (request) => ({ type: "file", request, read: { repo, branch, path: path11 } }), FILE_TIMEOUT_MS));
     if (file === null) {
-      throw new BoardError("NOT_FOUND", `${branch} has no ${path10 === "" ? "commit" : path10}`);
+      throw new BoardError("NOT_FOUND", `${branch} has no ${path11 === "" ? "commit" : path11}`);
     }
     return file;
   }
@@ -11975,11 +12065,11 @@ var RunnerHub = class {
    * What a branch of a project's repository did to one file since it left the default branch, read
    * on the runner the project lives on, with the same refusals as `branchChanges`.
    */
-  async branchDiff(project, branch, path10) {
+  async branchDiff(project, branch, path11) {
     const { seat, repo } = await this.projectSeat(project, "branchChanges", "list changes");
-    const diff = BranchFileDiffSchema.nullable().parse(await this.request(seat, (request) => ({ type: "diff", request, read: { repo, branch, path: path10 } }), FILE_TIMEOUT_MS));
+    const diff = BranchFileDiffSchema.nullable().parse(await this.request(seat, (request) => ({ type: "diff", request, read: { repo, branch, path: path11 } }), FILE_TIMEOUT_MS));
     if (diff === null) {
-      throw new BoardError("NOT_FOUND", `${branch} did not change ${path10}`);
+      throw new BoardError("NOT_FOUND", `${branch} did not change ${path11}`);
     }
     return diff;
   }
@@ -11990,7 +12080,7 @@ var RunnerHub = class {
    * back as a `BoardError` in the runner's words.
    */
   async readTurnImage(actor, file) {
-    const turn = this.host.runningTurns().find((each) => each.agent === actor.name && each.scope === actor.scope && each.thread === actor.thread && each.channel === actor.channel);
+    const turn = this.host.runningTurns().find((each) => each.agent === actor.name && each.scope === actor.scope && each.thread === actor.thread && each.channel === actor.channel && each.place === actor.place);
     if (turn === void 0) {
       throw new BoardError("INVALID_STATE", `${actor.name} has no turn running in this conversation to read ${file} from`);
     }
@@ -12223,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],
@@ -12245,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) => {
@@ -12266,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, {
@@ -12283,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";
@@ -12490,7 +12604,7 @@ function rateLimit(options) {
 }
 
 // apps/server/dist/runner-routes.js
-import path7 from "node:path";
+import path8 from "node:path";
 import { Hono as Hono2 } from "hono";
 import { streamSSE } from "hono/streaming";
 
@@ -12590,8 +12704,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);
@@ -12606,7 +12721,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) => {
@@ -12644,7 +12760,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 });
@@ -12653,21 +12769,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"));
@@ -12683,7 +12799,7 @@ function runnerRoutes(board2, hub, enrollments, enrollLimit) {
     const marker = `/homes/${agent}/git`;
     const at = c.req.path.indexOf(marker);
     return homeGit.serve({
-      root: path7.dirname(repository),
+      root: path8.dirname(repository),
       agent,
       rest: at === -1 ? "" : c.req.path.slice(at + marker.length),
       request: c.req.raw,
@@ -12696,7 +12812,7 @@ function runnerRoutes(board2, hub, enrollments, enrollLimit) {
 
 // apps/server/dist/static.js
 import { readFile as readFile5, stat as stat4 } from "node:fs/promises";
-import path8 from "node:path";
+import path9 from "node:path";
 var CONTENT_TYPES = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
@@ -12724,11 +12840,11 @@ function within2(root, pathname) {
   } catch {
     return null;
   }
-  const candidate = path8.resolve(root, `.${decoded}`);
-  return candidate === root || candidate.startsWith(root + path8.sep) ? candidate : null;
+  const candidate = path9.resolve(root, `.${decoded}`);
+  return candidate === root || candidate.startsWith(root + path9.sep) ? candidate : null;
 }
 function spaHandler(staticDir) {
-  const root = path8.resolve(staticDir);
+  const root = path9.resolve(staticDir);
   return async (c) => {
     const { pathname } = new URL(c.req.url);
     if (pathname.startsWith("/api/")) {
@@ -12739,14 +12855,14 @@ function spaHandler(staticDir) {
     if (file !== null && await isFile(file)) {
       return c.body(await readFile5(file), 200, {
         ...headers,
-        "content-type": CONTENT_TYPES[path8.extname(file)] ?? "application/octet-stream",
+        "content-type": CONTENT_TYPES[path9.extname(file)] ?? "application/octet-stream",
         "cache-control": pathname.startsWith("/assets/") ? "public, max-age=31536000, immutable" : "no-cache"
       });
     }
     if (pathname.startsWith("/assets/")) {
       return c.text("not found", 404, headers);
     }
-    const index = path8.join(root, "index.html");
+    const index = path9.join(root, "index.html");
     if (!await isFile(index)) {
       return c.text("The interface is not built: run pnpm build:web.", 404);
     }
@@ -12819,6 +12935,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") : {
@@ -12912,6 +13029,7 @@ function createApp(deps) {
   });
   api.get("/society/knowledge", async (c) => c.json(await board2.listKnowledge(null)));
   api.get("/skills", async (c) => c.json(await board2.listSocietySkills()));
+  api.get("/skills/:name/files", async (c) => c.json(await board2.readSocietySkillFiles(NameSchema.parse(c.req.param("name")))));
   api.post("/agents/:name/retire", async (c) => {
     const body = RetireBodySchema.parse(await c.req.json());
     const { tokenHash: _hash, ...agent } = await board2.retireAgent(c.get("actor"), {
@@ -12967,14 +13085,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) => {
@@ -13355,7 +13482,10 @@ var TurnHub = class {
   get lastSeq() {
     return this.seq;
   }
-  /** Records one event of a turn, in its scope and its conversation there: a thread's, a channel's, or home. */
+  /**
+   * Records one event of a turn, in its scope and its conversation there: a thread's, a channel's,
+   * a project's channels' in the society scope, or home.
+   */
   push(agent, project, event, conversation = {}) {
     this.seq += 1;
     const item = {
@@ -13365,6 +13495,7 @@ var TurnHub = class {
       project,
       ...conversation.thread === void 0 ? {} : { thread: conversation.thread },
       ...conversation.channel === void 0 ? {} : { channel: conversation.channel },
+      ...conversation.place === void 0 ? {} : { place: conversation.place },
       event
     };
     this.buffer.push(item);
@@ -13441,8 +13572,8 @@ var view = {
     return scheduler.activeSignals;
   }
 };
-var webDir = process.env["STELLARIS_WEB_DIR"] ?? path9.resolve(import.meta.dirname, "../../web/dist");
-var webBuilt = await access2(path9.join(webDir, "index.html")).then(() => true, () => false);
+var webDir = process.env["STELLARIS_WEB_DIR"] ?? path10.resolve(import.meta.dirname, "../../web/dist");
+var webBuilt = await access2(path10.join(webDir, "index.html")).then(() => true, () => false);
 var app = createApp({
   board,
   version: VERSION,