@kubitnodes/stellaris 0.3.23 → 0.3.25

package/dist/cli/index.js

@@ -2,12 +2,12 @@
 
 // apps/cli/dist/index.js
 import { readFile as readFile5 } from "node:fs/promises";
-import path7 from "node:path";
+import path8 from "node:path";
 import { Command } from "commander";
 
 // 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";
 
@@ -234,6 +234,7 @@ var CronFrontmatterSchema = z3.object({
   scope: NameSchema,
   thread: UlidSchema.optional(),
   channel: NameSchema.optional(),
+  place: NameSchema.optional(),
   schedule: CronScheduleSchema,
   createdBy: NameSchema,
   createdAt: IsoDateTimeSchema,
@@ -714,7 +715,6 @@ var ReallocationProposalSchema = z5.object({
   changes: RoleChangesSchema,
   description: z5.string().min(1)
 });
-var LegacyReallocationSchema = z5.object({ description: z5.string().min(1) });
 function applyRoleChanges(role2, changes) {
   return {
     ...role2,
@@ -759,8 +759,7 @@ var ArchiveProposalSchema = z5.object({
 });
 var SkillProposalSchema = z5.object({
   name: NameSchema,
-  summary: z5.string().min(1).max(200),
-  body: z5.string().min(1).optional()
+  summary: z5.string().min(1).max(200)
 });
 var ProposalCharterSchemas = {
   role: RoleCharterSchema,
@@ -837,14 +836,10 @@ function describeCharter(kind, charter) {
     }
     case "reallocation": {
       const parsed = ReallocationProposalSchema.safeParse(charter);
-      if (parsed.success) {
-        const { role: role2, changes, description } = parsed.data;
-        return `reallocation of role ${role2} (${describeRoleChanges(changes)}): ${description}`;
-      }
-      const legacy = LegacyReallocationSchema.safeParse(charter);
-      if (!legacy.success)
+      if (!parsed.success)
         break;
-      return `reallocation: ${legacy.data.description}`;
+      const { role: role2, changes, description } = parsed.data;
+      return `reallocation of role ${role2} (${describeRoleChanges(changes)}): ${description}`;
     }
     case "skill": {
       const parsed = SkillProposalSchema.safeParse(charter);
@@ -939,7 +934,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;
@@ -1048,12 +1044,10 @@ var VerbInputs = {
     channel: ChannelRefSchema.optional(),
     limit: z7.number().int().positive().max(100).default(20)
   }),
-  /** On a task or a proposal, whose id the thread takes, or on a channel with a title. */
+  /** On a channel with a title; a task's and a proposal's open with them. */
   open_thread: z7.object({
-    task_id: UlidSchema.optional(),
-    proposal_id: UlidSchema.optional(),
-    channel: ChannelRefSchema.optional(),
-    title: z7.string().min(1).max(200).optional()
+    channel: ChannelRefSchema,
+    title: z7.string().min(1).max(200)
   }),
   close_thread: z7.object({ thread_id: UlidSchema, summary: z7.string().min(1) }),
   create_task: z7.object({
@@ -1293,6 +1287,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"),
@@ -1344,6 +1339,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
 });
 
@@ -1430,7 +1427,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"),
@@ -1439,7 +1437,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,
@@ -1455,6 +1462,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.
@@ -1475,6 +1484,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,
@@ -1484,8 +1499,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(),
@@ -1494,6 +1525,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.
@@ -1612,7 +1648,8 @@ 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 })
 ]);
 var HeldWorkspaceSchema = z9.object({
   agent: NameSchema,
@@ -1718,6 +1755,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),
@@ -1725,7 +1763,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 channelConversation(scope, channel) {
   const at = channel.indexOf("/");
@@ -1733,6 +1777,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(),
@@ -1742,6 +1790,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(),
@@ -1765,6 +1815,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()
 });
@@ -1774,6 +1832,7 @@ var RunningTurnSchema = z10.object({
   scope: NameSchema,
   thread: UlidSchema.optional(),
   channel: NameSchema.optional(),
+  place: NameSchema.optional(),
   cli: CliKindSchema,
   askedIn: ChannelRefSchema.optional(),
   steerable: z10.boolean(),
@@ -1804,6 +1863,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(),
@@ -1832,9 +1893,19 @@ var OPS_SIGNAL_KINDS = [
   "runner",
   "home_conflict",
   "stuck_workspace",
-  "cron_failing"
+  "cron_failing",
+  "turn_refused"
 ];
 var OpsSignalKindSchema = z11.enum(OPS_SIGNAL_KINDS);
+var WAKING_SIGNAL_KINDS = [
+  "backlog",
+  "role_gap",
+  "churn",
+  "stale_thread",
+  "idle_member",
+  "blocked_capability",
+  "scaled"
+];
 var OpsSignalSchema = z11.object({
   kind: OpsSignalKindSchema,
   /** Identifies the condition, for example `backlog:demo:engineer`, so a persisting one is not logged again every pass. */
@@ -1847,8 +1918,15 @@ var OpsSignalSchema = z11.object({
   project: NameSchema.optional(),
   agent: NameSchema.optional(),
   role: NameSchema.optional(),
-  taskId: UlidSchema.optional()
+  taskId: UlidSchema.optional(),
+  /**
+   * Whether this log of the condition wakes the roles charted for `ops_event`, as its publisher
+   * decided: the operations pass wakes them when a condition is new, and again only at the steps
+   * it names, not at every repeat. Absent, the kind decides.
+   */
+  wakes: z11.boolean().optional()
 });
+var WAKING = new Set(WAKING_SIGNAL_KINDS);
 
 // packages/shared/dist/metrics.js
 import { z as z12 } from "zod";
@@ -2006,7 +2084,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";
@@ -2387,6 +2465,7 @@ var HOME_GITIGNORE = [
   "/projects/*/last-turn.json",
   "/projects/*/threads/",
   "/projects/*/channels/",
+  "/projects/*/places/",
   `/${HOME_SCRATCH}/`,
   "*.tmp",
   "node_modules/",
@@ -2404,7 +2483,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
@@ -2730,6 +2809,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({
@@ -2775,11 +2855,16 @@ function answers(mention, turn2) {
   if (!mention.scopes.includes(turn2.project)) {
     return false;
   }
-  const own = mention.thread === null ? channelConversation(turn2.project, mention.channel) : void 0;
+  const topLevel = mention.thread === null;
+  const own = topLevel ? channelConversation(turn2.project, mention.channel) : void 0;
+  const place = topLevel ? placeConversation(turn2.project, mention.channel) : void 0;
   if (turn2.channel !== null) {
-    return mention.thread === null && own === turn2.channel;
+    return topLevel && own === turn2.channel;
+  }
+  if (turn2.place !== null) {
+    return topLevel && place === turn2.place;
   }
-  return mention.thread === null && own === void 0 || turn2.trigger === "mention";
+  return topLevel && own === void 0 && place === void 0 || turn2.trigger === "mention";
 }
 function computeMetrics(input) {
   const { events, now, window } = input;
@@ -2845,6 +2930,7 @@ function computeMetrics(input) {
           at,
           thread: turn2.data.thread ?? null,
           channel: turn2.data.channel ?? null,
+          place: turn2.data.place ?? null,
           project: turn2.data.project,
           trigger: turn2.data.trigger
         };
@@ -3044,6 +3130,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),
@@ -3282,11 +3369,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");
@@ -3320,6 +3410,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() {
@@ -3333,7 +3528,7 @@ function hashToken(token) {
 var SYSTEM_ACTOR = { name: "board", role: USER_ROLE };
 var CLOSING_ATTEMPTS = 3;
 function ownTurn(actor, turn2) {
-  return turn2.agent === actor.name && turn2.scope === actor.scope && turn2.thread === actor.thread && turn2.channel === actor.channel;
+  return turn2.agent === actor.name && turn2.scope === actor.scope && turn2.thread === actor.thread && turn2.channel === actor.channel && turn2.place === actor.place;
 }
 function namesList(names) {
   return names.length <= 1 ? names[0] ?? "" : `${names.slice(0, -1).join(", ")} and ${names.at(-1) ?? ""}`;
@@ -3346,37 +3541,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) {
@@ -3390,7 +3593,7 @@ function cursorOf(cursors, scope, part = null) {
   if (part === null) {
     return cursors.scopes[scope] ?? cursors.digest;
   }
-  return cursors.scopes[conversationKey(scope, part)] ?? (part.startsWith("#") ? channelStart(cursors, scope) : 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;
@@ -3398,21 +3601,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(proposal2) {
   if (proposal2.kind !== "skill") {
     return null;
   }
   const parsed = SkillProposalSchema.safeParse(proposal2.charter);
-  return parsed.success && parsed.data.body === void 0 ? parsed.data.name : null;
+  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$/, "");
@@ -3424,27 +3629,6 @@ var FRONT_DESK_TRIGGER = "user_post";
 var OPS_CHANNELS = ["governance"];
 var FRONT_DESK_CHANNELS = [ASK_CHANNEL];
 var AlignmentsSchema = z16.object({ applied: z16.array(z16.string()).default([]) });
-var FOLLOW_DECISIONS = "ops-readers-follow-decisions";
-var THREAD_RECORDS = "threads-as-records";
-var DIGEST_CURSORS = "digest-replaces-inbox";
-var TASK_RETURNS = "task-returns-recorded";
-var OPS_CHANNEL_RETIRED = "ops-channel-retired";
-var DECISIONS_CHANNEL_RETIRED = "decisions-channel-retired";
-var THREAD_CONVERSATIONS = "thread-conversations";
-var ASKS_CHANNEL_OPENED = "asks-channel-opened";
-var KNOWLEDGE_REMOVAL = "knowledge-removal-granted";
-var CHANNEL_CONVERSATIONS = "channel-conversations";
-var 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"];
@@ -3464,9 +3648,9 @@ function sentence(summary) {
   return summary.trim().replace(/\.+$/, "");
 }
 function skillSummary(data, body) {
-  const fromFrontmatter = data["description"] ?? data["summary"];
-  if (typeof fromFrontmatter === "string" && fromFrontmatter.trim().length > 0) {
-    return fromFrontmatter.trim();
+  const description = data["description"];
+  if (typeof description === "string" && description.trim().length > 0) {
+    return description.trim();
   }
   return body.split("\n").map((line) => line.trim()).find((line) => line.length > 0 && !line.startsWith("#")) ?? "";
 }
@@ -3508,8 +3692,8 @@ function restage(existing, edit) {
   };
 }
 function reopenStage(stage) {
-  const { completedBy: _by, completedAt: _at, ...open3 } = stage;
-  return open3;
+  const { completedBy: _by, completedAt: _at, ...open4 } = stage;
+  return open4;
 }
 function gateChanges(before, after) {
   const changes = [];
@@ -3590,7 +3774,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);
@@ -3619,368 +3803,22 @@ var Board = class _Board {
     return board;
   }
   /**
-   * Applies each one-time alignment an existing society has not had yet. Once applied it is not
-   * repeated, so a member that later chooses otherwise keeps its choice.
+   * Applies each one-time alignment an existing society has not had yet, and remembers it, so a
+   * member that later chooses otherwise keeps its choice. A new alignment is a name and a method in
+   * this list; once every board has applied it, both are deleted. None is pending.
    */
   async applyAlignments() {
-    const 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();
+    for (const { apply } of pending) {
+      await apply();
     }
-    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 knowledge2 = KnowledgeEventSchema.safeParse(verb.payload);
-      const id = UlidSchema.safeParse(event.payload["id"]);
-      if (!knowledge2.success || !id.success || (event.payload["thread"] ?? null) !== null || event.payload["channel"] !== channelRef(knowledge2.data.project, "general")) {
-        continue;
-      }
-      const { topic, project: project2, replaced } = knowledge2.data;
-      const file = this.paths.messageFile(this.paths.channelDir(channelRef(project2, "general")), id.data, event.actor);
-      if (!await exists(file)) {
-        continue;
-      }
-      const { data, body, error } = await readLooseMarkdown(file);
-      if (error !== null || data["notice"] !== void 0) {
-        continue;
-      }
-      const notice = {
-        kind: "knowledge",
-        action: verb.type === "knowledge.removed" ? "removed" : replaced === true ? "updated" : "written",
-        topic,
-        project: project2
-      };
-      await writeMarkdown(file, { ...data, notice }, body);
-    }
-  }
-  /**
-   * Grants `verb` once to every charter granting `beside`, the work roles' charters in practice;
-   * seed roles have it from their seed.
-   */
-  async grantBeside(beside, verb) {
-    for (const charter of await this.listRoles()) {
-      if (charter.verbs.includes(beside) && !charter.verbs.includes(verb)) {
-        await this.writeRoleUnlocked(USER_NAME, { ...charter, verbs: [...charter.verbs, verb] }, { verbsAdded: [verb] });
-      }
-    }
-  }
-  /** Grants verbs once to every charter but the user's, which holds every verb already. */
-  async grantToEveryRole(verbs) {
-    for (const charter of await this.listRoles()) {
-      const missing = verbs.filter((verb) => !charter.verbs.includes(verb));
-      if (charter.name !== USER_ROLE && missing.length > 0) {
-        await this.writeRoleUnlocked(USER_NAME, { ...charter, verbs: [...charter.verbs, ...missing] }, { verbsAdded: missing });
-      }
-    }
-  }
-  /** A dashboard still saying agents may edit its file says how it changes now. */
-  async rewordDashboards() {
-    for (const slug of await listDirs(this.paths.projects())) {
-      const file = this.paths.dashboard(slug);
-      if (!await exists(file)) {
-        continue;
-      }
-      const { data, body } = await readLooseMarkdown(file);
-      if (body.includes(OLD_DASHBOARD_LINE)) {
-        await writeMarkdown(file, data, body.replace(OLD_DASHBOARD_LINE, DASHBOARD_LINE));
-      }
-    }
-  }
-  /**
-   * A task sent back before tasks recorded it kept no trace outside the event log. A task still
-   * short of the stage its latest `task.moved` came from is in that rework, and records it.
-   */
-  async recordTaskReturns() {
-    const moves = /* @__PURE__ */ new Map();
-    for (const event of await this.events.readSince(null, Number.POSITIVE_INFINITY)) {
-      const taskId = event.payload["taskId"];
-      if (event.type === "task.moved" && typeof taskId === "string") {
-        moves.set(taskId, event);
-      }
-    }
-    for (const slug of await listDirs(this.paths.projects())) {
-      for (const task2 of await this.listTasks(slug)) {
-        const move = moves.get(task2.id);
-        const from = move?.payload["from"];
-        if (move === void 0 || typeof from !== "string" || task2.returned !== void 0 || task2.completing || task2.status !== "open" && task2.status !== "claimed") {
-          continue;
-        }
-        const back = stageIndex(task2, from);
-        if (back > stageIndex(task2, task2.stage)) {
-          await this.writeTask(slug, {
-            ...task2,
-            returned: { from, by: move.actor, at: move.ts }
-          });
-        }
-      }
-    }
-  }
-  /**
-   * A society channel the board no longer uses leaves the society's list and every member's
-   * subscriptions; its old posts stay on disk. `ops` carried operations signals, which are only
-   * logged now; `decisions` carried proposals' outcomes, which are posts in their threads now, and
-   * requests to the user, which are mentions of the user wherever the question belongs.
-   */
-  async retireSocietyChannel(name) {
-    const doc = await readMarkdown(this.paths.societyFile(), SocietySchema);
-    if (doc.data.channels.includes(name)) {
-      await writeMarkdown(this.paths.societyFile(), { ...doc.data, channels: doc.data.channels.filter((channel) => channel !== name) }, doc.body);
-    }
-    for (const agent2 of await this.listAgents()) {
-      if (agent2.subscriptions.includes(name)) {
-        await this.updateAgent(agent2.name, (a) => ({
-          ...a,
-          subscriptions: a.subscriptions.filter((ref) => ref !== name)
-        }));
-        await this.refreshMember(agent2.name);
-      }
-    }
-  }
-  /**
-   * Asks once opened their threads in general, where closing one posted its summary to every
-   * citizen and woke the steward's heartbeat for it. The society gains the asks channel, and the
-   * front desk follows it.
-   */
-  async openAsksChannel() {
-    const doc = await readMarkdown(this.paths.societyFile(), SocietySchema);
-    if (!doc.data.channels.includes(ASK_CHANNEL)) {
-      await writeMarkdown(this.paths.societyFile(), { ...doc.data, channels: [...doc.data.channels, ASK_CHANNEL] }, doc.body);
-    }
-    await ensureDir(this.paths.societyChannel(ASK_CHANNEL));
-    for (const agent2 of await this.listAgents()) {
-      if (agent2.status !== "active" || agent2.subscriptions.includes(ASK_CHANNEL)) {
-        continue;
-      }
-      if (!(await this.readRole(agent2.role)).wakeTriggers.includes(FRONT_DESK_TRIGGER)) {
-        continue;
-      }
-      await this.updateAgent(agent2.name, (a) => ({
-        ...a,
-        subscriptions: [...a.subscriptions, ASK_CHANNEL]
-      }));
-      await this.refreshMember(agent2.name);
-      await this.events.append("subscription.changed", agent2.name, {
-        channel: ASK_CHANNEL,
-        subscribed: true,
-        aligned: true
-      });
-    }
-  }
-  /** Members that predate `decisions` among the ops channels read proposals without their outcome. */
-  async followDecisions() {
-    if (!(await this.society()).channels.includes("decisions")) {
-      return;
-    }
-    for (const agent2 of await this.listAgents()) {
-      if (agent2.status !== "active" || agent2.subscriptions.includes("decisions")) {
-        continue;
-      }
-      if (!(await this.readRole(agent2.role)).wakeTriggers.includes(OPS_WAKE_TRIGGER)) {
-        continue;
-      }
-      await this.updateAgent(agent2.name, (a) => ({
-        ...a,
-        subscriptions: [...a.subscriptions, "decisions"]
-      }));
-      await this.refreshMember(agent2.name);
-      await this.events.append("subscription.changed", agent2.name, {
-        channel: "decisions",
-        subscribed: true,
-        aligned: true
-      });
-    }
-  }
-  /**
-   * Threads were once a state field on their task. Each becomes a record under the task's project,
-   * on its general channel, closed if its task has ended, and the field leaves the task file.
-   */
-  async recordTaskThreads() {
-    const opened = /* @__PURE__ */ new Map();
-    const closed = /* @__PURE__ */ new Map();
-    for (const event of await this.events.readSince(null, Number.POSITIVE_INFINITY)) {
-      const taskId = event.payload["taskId"];
-      if (typeof taskId !== "string") {
-        continue;
-      }
-      if (event.type === "thread.opened") {
-        opened.set(taskId, event);
-      } else if (event.type === "thread.closed") {
-        closed.set(taskId, event);
-      }
-    }
-    for (const slug of await listDirs(this.paths.projects())) {
-      const threads = this.paths.threads(slug);
-      const summaries = /* @__PURE__ */ new Map();
-      for (const message of await this.readMessagesIn(this.paths.projectChannel(slug, "general"), null)) {
-        if (message.task !== void 0) {
-          summaries.set(message.task, message.body.replace(/^Thread closed[^\n]*\n\n/, ""));
-        }
-      }
-      for (const file of await listFiles(this.paths.tasks(slug))) {
-        const raw = await readMarkdown(path6.join(this.paths.tasks(slug), file), z16.record(z16.string(), z16.unknown()));
-        const legacy = raw.data["thread"];
-        if (legacy === void 0) {
-          continue;
-        }
-        const task2 = { ...TaskFrontmatterSchema.parse(raw.data), body: raw.body };
-        if ((legacy === "open" || legacy === "closed") && !await exists(this.paths.threadFile(threads, task2.id))) {
-          const ended = task2.status === "done" || task2.status === "abandoned";
-          const open3 = legacy === "open" && !ended;
-          const openedBy = opened.get(task2.id);
-          const closedBy = closed.get(task2.id);
-          await this.writeThread(threads, {
-            id: task2.id,
-            channel: channelRef(slug, "general"),
-            title: task2.title,
-            subject: { kind: "task", id: task2.id },
-            state: open3 ? "open" : "closed",
-            openedBy: openedBy?.actor ?? task2.createdBy,
-            openedAt: openedBy?.ts ?? task2.createdAt,
-            ...open3 ? {} : {
-              closedBy: closedBy?.actor ?? SYSTEM_ACTOR.name,
-              closedAt: closedBy?.ts ?? this.now().toISOString()
-            },
-            body: summaries.get(task2.id) ?? ""
-          });
-        }
-        await this.writeTask(slug, task2);
-      }
-    }
-  }
-  /**
-   * Every channel of a scope was once read in its home conversation, so a member had read each up
-   * to its scope's cursor. Each channel beside general starts from that cursor now, as each takes a
-   * conversation of its own.
-   */
-  async startChannelCursors() {
-    for (const agent2 of await this.listAgents()) {
-      const file = this.paths.agentCursors(agent2.name);
-      if (!await exists(file)) {
-        continue;
-      }
-      const cursors = await readJson(file, CursorsSchema);
-      const scopes = /* @__PURE__ */ new Set([
-        ...Object.keys(cursors.scopes).filter((key) => !key.includes("/")),
-        ...agent2.memberships,
-        SOCIETY_SCOPE
-      ]);
-      const channelsFrom = Object.fromEntries([...scopes].map((scope) => [scope, cursorOf(cursors, scope)]));
-      await writeJson(file, { ...cursors, channelsFrom });
-    }
-  }
-  /**
-   * Threads were once read in the scope's single conversation, so a member had read every thread
-   * up to its scope's cursor. Each scope's threads start from that cursor now, as each thread's
-   * conversation takes a cursor of its own.
-   */
-  async startThreadCursors() {
-    for (const agent2 of await this.listAgents()) {
-      const file = this.paths.agentCursors(agent2.name);
-      if (!await exists(file)) {
-        continue;
-      }
-      const cursors = await readJson(file, CursorsSchema);
-      const scopes = /* @__PURE__ */ new Set([
-        ...Object.keys(cursors.scopes).filter((key) => !key.includes("/")),
-        ...agent2.memberships,
-        SOCIETY_SCOPE
-      ]);
-      const threadsFrom = Object.fromEntries([...scopes].map((scope) => [scope, cursorOf(cursors, scope)]));
-      await writeJson(file, { ...cursors, threadsFrom });
-    }
-  }
-  /**
-   * The digest was once called the inbox: each cursor file keyed its cursor `inbox`, and the user
-   * followed every society channel and project general channel to read one. The user takes no
-   * turns, so it follows nothing now.
-   */
-  async renameInboxCursors() {
-    const Legacy = z16.object({ inbox: z16.string().nullable() });
-    for (const agent2 of await this.listAgents()) {
-      const file = this.paths.agentCursors(agent2.name);
-      if (await exists(file)) {
-        const legacy = Legacy.safeParse(JSON.parse(await readFile4(file, "utf8")));
-        if (legacy.success) {
-          await writeJson(file, { digest: legacy.data.inbox });
-        }
-      }
-    }
-    await this.updateAgent(USER_NAME, (user2) => ({ ...user2, subscriptions: [] }));
-    await this.refreshMember(USER_NAME);
+    await writeJson(file, { applied: [...applied, ...pending.map(({ name }) => name)] });
   }
   /** Writes every missing seed charter and aligns the existing ones with their seed. */
   async ensureSeedRoles() {
@@ -4082,13 +3920,15 @@ ${charter.purpose}
     const token = mintToken();
     const thread2 = threadOfPart(part);
     const channel = channelOfPart(part);
+    const place = placeOfPart(part);
     this.turnTokens.set(hashToken(token), {
       actor: {
         name: agent2,
         role: role2,
         ...scope === void 0 ? {} : { scope },
         ...thread2 === void 0 ? {} : { thread: thread2 },
-        ...channel === void 0 ? {} : { channel }
+        ...channel === void 0 ? {} : { channel },
+        ...place === void 0 ? {} : { place }
       },
       expiresAt: this.now().getTime() + ttlMs
     });
@@ -4177,7 +4017,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();
@@ -4274,7 +4114,7 @@ ${charter.purpose}
     const files = await listFiles(this.paths.tasks(project2));
     const tasks = [];
     for (const file of files) {
-      const doc = await readMarkdown(path6.join(this.paths.tasks(project2), file), TaskFrontmatterSchema);
+      const doc = await readMarkdown(path7.join(this.paths.tasks(project2), file), TaskFrontmatterSchema);
       tasks.push({ ...doc.data, body: doc.body });
     }
     return tasks;
@@ -4293,7 +4133,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;
@@ -4320,7 +4160,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;
@@ -4339,7 +4179,7 @@ ${charter.purpose}
     const dir = project2 === null ? this.paths.societyKnowledge() : this.paths.projectKnowledge(project2);
     const topics = [];
     for (const file of await listFiles(dir)) {
-      topics.push(await this.knowledgeAt(path6.join(dir, file), project2, file.replace(/\.md$/, "")));
+      topics.push(await this.knowledgeAt(path7.join(dir, file), project2, file.replace(/\.md$/, "")));
     }
     return topics;
   }
@@ -4369,7 +4209,7 @@ ${charter.purpose}
     const aside = this.paths.removedKnowledge(project2 ?? SOCIETY_SCOPE);
     let highest = 0;
     for (const file of (await listFiles(aside)).filter((name) => name.startsWith(`${topic}.`))) {
-      const copy = await this.knowledgeAt(path6.join(aside, file), project2, topic);
+      const copy = await this.knowledgeAt(path7.join(aside, file), project2, topic);
       highest = Math.max(highest, copy.revision);
     }
     return highest;
@@ -4385,7 +4225,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;
       }
@@ -4475,7 +4315,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) {
@@ -4507,7 +4347,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;
         }
@@ -4534,7 +4374,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({
@@ -4782,7 +4622,7 @@ ${DASHBOARD_LINE}
       if (event.type === "turn.started") {
         const start = TurnStartPayloadSchema.safeParse(event.payload);
         if (start.success)
-          starts.set(start.data.turnId ?? start.data.project, event.ts);
+          starts.set(start.data.turnId, event.ts);
         continue;
       }
       if (event.type !== "turn.completed" && event.type !== "turn.failed") {
@@ -4790,9 +4630,11 @@ ${DASHBOARD_LINE}
       }
       const parsed = TurnHistoryPayloadSchema.safeParse(event.payload);
       if (parsed.success) {
-        const key = parsed.data.turnId ?? parsed.data.project;
-        const startedAt = starts.get(key);
-        starts.delete(key);
+        const { turnId } = parsed.data;
+        const startedAt = turnId === void 0 ? void 0 : starts.get(turnId);
+        if (turnId !== void 0) {
+          starts.delete(turnId);
+        }
         entries.push({
           id: event.id,
           ts: event.ts,
@@ -4901,16 +4743,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) {
@@ -4920,11 +4766,23 @@ ${DASHBOARD_LINE}
       if (posted !== scope && scope !== SOCIETY_SCOPE) {
         continue;
       }
+      const thread2 = threadOfPart(part);
+      if (thread2 !== void 0) {
+        let ended = closed.get(thread2);
+        if (ended === void 0) {
+          ended = (await this.tryFindThread(thread2))?.thread.state === "closed";
+          closed.set(thread2, ended);
+        }
+        if (ended) {
+          continue;
+        }
+      }
       const key = conversationKey(scope, part);
       const entry = counts.get(key) ?? {
         scope,
-        thread: threadOfPart(part) ?? null,
+        thread: thread2 ?? null,
         channel: channelOfPart(part) ?? null,
+        place: placeOfPart(part) ?? null,
         count: 0
       };
       counts.set(key, { ...entry, count: entry.count + 1 });
@@ -4982,8 +4840,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) {
@@ -5003,11 +4862,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] : [...agent2.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);
@@ -5017,7 +4882,7 @@ ${DASHBOARD_LINE}
       const thread2 = message.thread ?? null;
       const asked = message.mentions.includes(actor.name) || frontDesk && message.author === USER_NAME;
       if (newsFrom !== void 0 && thread2 === 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,
@@ -5028,12 +4893,18 @@ ${DASHBOARD_LINE}
         continue;
       }
       const named = thread2 === null ? channelConversation(filedIn, message.channel) : void 0;
-      let open3 = named === void 0 ? void 0 : openChannels.get(message.channel);
-      if (named !== void 0 && open3 === void 0) {
-        open3 = await this.channelOpen(message.channel);
-        openChannels.set(message.channel, open3);
-      }
-      const part = thread2 ?? (open3 === true ? `#${named}` : null);
+      let open4 = named === void 0 ? void 0 : openChannels.get(message.channel);
+      if (named !== void 0 && open4 === void 0) {
+        open4 = await this.channelOpen(message.channel);
+        openChannels.set(message.channel, open4);
+      }
+      const project2 = thread2 === null ? placeConversation(filedIn, message.channel) : void 0;
+      let live = project2 === void 0 ? void 0 : liveProjects.get(project2);
+      if (project2 !== void 0 && live === void 0) {
+        live = await this.projectLive(project2);
+        liveProjects.set(project2, live);
+      }
+      const part = thread2 ?? (open4 === true ? `#${named}` : live === true ? `~${project2}` : null);
       if (conversation !== void 0 && (filedIn !== conversation.scope || part !== conversation.part)) {
         continue;
       }
@@ -5098,7 +4969,7 @@ ${task2.body}`;
         }
       }
       for (const file of await listFiles(this.paths.projectKnowledge(project2))) {
-        const content = await readFile4(path6.join(this.paths.projectKnowledge(project2), file), "utf8");
+        const content = await readFile4(path7.join(this.paths.projectKnowledge(project2), file), "utf8");
         if (content.toLowerCase().includes(needle)) {
           hits.push({
             kind: "knowledge",
@@ -5119,7 +4990,7 @@ ${task2.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 skill2 of await this.listSocietySkills()) {
@@ -5132,7 +5003,7 @@ ${task2.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) {
@@ -5222,7 +5093,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
@@ -5270,7 +5141,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
@@ -5347,7 +5218,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,
@@ -5373,7 +5244,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;
   }
@@ -5495,11 +5366,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, agent2, named) {
     const own = actor.name === agent2.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, agent2, {
         project: actor.scope,
         thread_id: actor.thread,
@@ -5575,7 +5451,8 @@ ${current.body}`);
       agent: cron2.agent,
       project: cron2.scope,
       ...cron2.thread === void 0 ? {} : { thread: cron2.thread },
-      ...cron2.channel === void 0 ? {} : { channel: cron2.channel }
+      ...cron2.channel === void 0 ? {} : { channel: cron2.channel },
+      ...cron2.place === void 0 ? {} : { place: cron2.place }
     };
   }
   async readCronFile(file) {
@@ -5608,11 +5485,12 @@ ${current.body}`);
     const args = VerbInputs.open_thread.parse(input);
     await this.authorize(actor, "open_thread");
     return this.mutex.run(async () => {
-      const opening = await this.threadToOpen(args);
-      if (await this.tryFindThread(opening.id) !== null) {
-        throw new BoardError("INVALID_STATE", `${opening.subject?.kind ?? "thread"} ${opening.id} already has a thread`);
-      }
-      return this.openThreadUnlocked(actor.name, opening);
+      await this.assertChannelOpen(args.channel);
+      return this.openThreadUnlocked(actor.name, {
+        id: this.newId(),
+        channel: args.channel,
+        title: args.title
+      });
     });
   }
   /** Writes a new open thread and its event. Callers hold the mutex and chose where it hangs. */
@@ -5647,28 +5525,13 @@ ${current.body}`);
       subject: { kind: "proposal", id: proposal2.id }
     };
   }
-  /**
-   * The open thread of a proposal being decided. A proposal from before proposals opened their
-   * threads gets one now, opened as its proposer, and a thread closed before the decision opens
-   * again.
-   */
-  async proposalThreadUnlocked(by, proposal2) {
+  /** The open thread of a proposal being decided, which `propose` opened with it. */
+  async proposalThreadUnlocked(proposal2) {
     const found = await this.tryFindThread(proposal2.id);
-    if (found?.thread.state === "open") {
-      return found.thread;
-    }
-    if (found === null) {
-      return this.openThreadUnlocked(proposal2.proposedBy, this.proposalThreadOpening(proposal2));
+    if (found?.thread.state !== "open") {
+      throw new BoardError("INVALID_STATE", `proposal ${proposal2.id} has no open thread`);
     }
-    const { closedBy: _by, closedAt: _at, ...kept } = found.thread;
-    const reopened = await this.writeThread(found.threads, { ...kept, state: "open" });
-    await this.events.append("thread.opened", by, {
-      threadId: proposal2.id,
-      channel: reopened.channel,
-      subject: reopened.subject ?? null,
-      reopened: true
-    });
-    return reopened;
+    return found.thread;
   }
   /** Where a task's thread hangs, what it is called, and what it is about. */
   taskThreadOpening(task2) {
@@ -5680,79 +5543,21 @@ ${current.body}`);
     };
   }
   /**
-   * The open thread of a task in play, for a verb about to post into it. A task from before tasks
-   * opened their threads gets one now, and a thread closed early while its task is in play opens
-   * again; an ended task's thread stays closed.
+   * The open thread of a task in play, for a verb about to post into it, which `createTask` opened
+   * with the task; an ended task's thread closed with it.
    */
-  async taskThreadUnlocked(by, task2) {
+  async taskThreadUnlocked(task2) {
     const found = await this.tryFindThread(task2.id);
     if (found?.thread.state === "open") {
       return found.thread;
     }
-    if (task2.status === "done" || task2.status === "abandoned") {
-      throw new BoardError("INVALID_STATE", `task ${task2.id} is ${task2.status} and its thread closed with it`);
-    }
-    if (found === null) {
-      return this.openThreadUnlocked(by, this.taskThreadOpening(task2));
-    }
-    const { closedBy: _by, closedAt: _at, ...kept } = found.thread;
-    const reopened = await this.writeThread(found.threads, { ...kept, state: "open" });
-    await this.events.append("thread.opened", by, {
-      threadId: task2.id,
-      channel: reopened.channel,
-      subject: reopened.subject ?? null,
-      reopened: true
-    });
-    return reopened;
+    throw new BoardError("INVALID_STATE", task2.status === "done" || task2.status === "abandoned" ? `task ${task2.id} is ${task2.status} and its thread closed with it` : `task ${task2.id} has no open thread`);
   }
   /** Posts what a task verb was told to say into the task's thread, as its author, with the step it recorded. */
   async postTaskNote(author, task2, body, step) {
-    const thread2 = await this.taskThreadUnlocked(author, task2);
+    const thread2 = await this.taskThreadUnlocked(task2);
     return this.appendThreadMessage(author, thread2.id, body, step === void 0 ? {} : { step });
   }
-  /** Where a new thread hangs, what it is called, and what it is about. */
-  async threadToOpen(args) {
-    if (args.task_id !== void 0 && args.proposal_id !== void 0) {
-      throw new BoardError("VALIDATION", "a thread is about one task or one proposal, not both");
-    }
-    if (args.task_id !== void 0) {
-      const { task: task2, project: project2 } = await this.findTask(args.task_id);
-      if (task2.status === "done" || task2.status === "abandoned") {
-        throw new BoardError("INVALID_STATE", `task ${task2.id} is ${task2.status}`);
-      }
-      const channel = args.channel ?? channelRef(project2, task2.channel);
-      if (parseChannelRef(channel).project !== project2) {
-        throw new BoardError("VALIDATION", `a task's thread hangs off a channel of its project, ${project2}`);
-      }
-      await this.assertChannelOpen(channel);
-      return {
-        id: task2.id,
-        channel,
-        title: args.title ?? task2.title,
-        subject: { kind: "task", id: task2.id }
-      };
-    }
-    if (args.proposal_id !== void 0) {
-      const proposal2 = await this.readProposal(args.proposal_id);
-      if (proposal2.status !== "proposed") {
-        throw new BoardError("INVALID_STATE", `proposal ${proposal2.id} is already ${proposal2.status}`);
-      }
-      const channel = args.channel ?? "governance";
-      await this.assertChannelOpen(channel);
-      const described = `${proposal2.kind} proposal: ${describeCharter(proposal2.kind, proposal2.charter)}`;
-      return {
-        id: proposal2.id,
-        channel,
-        title: args.title ?? described.slice(0, 200),
-        subject: { kind: "proposal", id: proposal2.id }
-      };
-    }
-    if (args.channel === void 0 || args.title === void 0) {
-      throw new BoardError("VALIDATION", "a thread needs a task_id, a proposal_id, or a channel and a title");
-    }
-    await this.assertChannelOpen(args.channel);
-    return { id: this.newId(), channel: args.channel, title: args.title };
-  }
   /**
    * Where the board learns which turns are in flight, from the server that hosts them, so it
    * refuses to end a conversation under someone else's turn.
@@ -5786,17 +5591,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`, (turn2) => turn2.scope === slug || turn2.thread !== void 0 && threads.has(turn2.thread));
+    this.assertNoTurnCut(actor, `project ${slug} cannot be archived`, (turn2) => turn2.scope === slug || turn2.place === slug || turn2.thread !== void 0 && threads.has(turn2.thread));
   }
   async closeThread(actor, input) {
     const args = VerbInputs.close_thread.parse(input);
@@ -6337,7 +6145,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
@@ -6749,19 +6558,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(agent2, scope, part) {
     return part === void 0 ? this.paths.agentProject(agent2, scope) : this.paths.agentConversation(agent2, scope, part);
   }
   async readSessions(agent2, project2, part) {
-    const file = path6.join(this.sessionDir(agent2, project2, part), "sessions.json");
+    const file = path7.join(this.sessionDir(agent2, project2, part), "sessions.json");
     return await exists(file) ? readJson(file, SessionsFileSchema) : {};
   }
   /**
@@ -6772,15 +6582,34 @@ ${rationale}`}`);
     await this.mutex.run(async () => {
       const dir = this.sessionDir(agent2, project2, 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 === runner2 ? current : {};
       await writeJson(file, { ...kept, [cli]: sessionId, runner: runner2 });
     });
   }
-  /** 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(agent2, project2, cli, sessionId, part) {
+    return this.mutex.run(async () => {
+      const file = path7.join(this.sessionDir(agent2, project2, 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(agent2, project2, part) {
-    const file = path6.join(this.sessionDir(agent2, project2, part), "last-turn.json");
+    const file = path7.join(this.sessionDir(agent2, project2, 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. */
@@ -6788,8 +6617,9 @@ ${rationale}`}`);
     let latest = await this.readLastTurn(agent2, project2);
     const place = this.paths.agentProject(agent2, project2);
     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 turn2 = await this.readLastTurn(agent2, project2, part);
@@ -6810,6 +6640,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
@@ -6839,7 +6670,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, {
@@ -6847,6 +6679,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,
@@ -6856,7 +6689,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 } : {}
       });
     });
   }
@@ -6893,6 +6729,20 @@ ${rationale}`}`);
       return task2;
     });
   }
+  /**
+   * 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
@@ -6903,7 +6753,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;
@@ -6955,9 +6805,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));
@@ -7031,11 +6885,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) {
@@ -7066,7 +6920,7 @@ ${rationale}`}`);
   async listRunners() {
     const runners = [];
     for (const file of await listFiles(this.paths.runners())) {
-      runners.push((await readMarkdown(path6.join(this.paths.runners(), file), RunnerSchema)).data);
+      runners.push((await readMarkdown(path7.join(this.paths.runners(), file), RunnerSchema)).data);
     }
     return runners;
   }
@@ -7118,7 +6972,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();
@@ -7167,26 +7021,26 @@ ${rationale}`}`);
   async listHomeConflicts(agent2) {
     const home = this.paths.agent(agent2);
     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. */
@@ -7263,7 +7117,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
@@ -7382,8 +7236,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"), {});
     }
   }
   /**
@@ -7415,7 +7269,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       const at = turn2?.endedAt ?? turn2?.startedAt;
       if (turn2 !== null && at !== void 0 && (lastTurnAt === void 0 || at > lastTurnAt)) {
         lastTurnAt = at;
-        lastTurnOutcome = `${turn2.trigger.kind} on ${scope}: ${turn2.exitReason ?? "running"}${turn2.status === null ? "" : `, ${turn2.status.summary.slice(0, 160)}`}`;
+        lastTurnOutcome = `${turn2.trigger.kind} on ${scope}${turnConversation(turn2)}: ${turn2.exitReason ?? "running"}${turn2.status === null ? "" : `, ${turn2.status.summary.slice(0, 160)}`}`;
         lastModel = turn2.model ?? void 0;
       }
     }
@@ -7545,15 +7399,9 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       case "archive":
         await this.validateArchive(ArchiveProposalSchema.parse(charter).project);
         return;
-      case "reallocation": {
-        const parsed = ReallocationProposalSchema.safeParse(charter);
-        if (parsed.success) {
-          await this.reallocatedRole(parsed.data);
-        } else {
-          LegacyReallocationSchema.parse(charter);
-        }
+      case "reallocation":
+        await this.reallocatedRole(ReallocationProposalSchema.parse(charter));
         return;
-      }
       default:
         return;
     }
@@ -7613,11 +7461,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
         return { project: input.project, members };
       }
       case "reallocation": {
-        const parsed = ReallocationProposalSchema.safeParse(proposal2.charter);
-        if (!parsed.success) {
-          return void 0;
-        }
-        const { next, changed } = await this.reallocatedRole(parsed.data);
+        const { next, changed } = await this.reallocatedRole(ReallocationProposalSchema.parse(proposal2.charter));
         await this.writeRoleUnlocked(by, next, meta);
         return { role: next.name, changed };
       }
@@ -7627,25 +7471,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, proposal2, skill2, meta) {
     const dir = this.paths.societySkill(skill2.name);
     const file = this.paths.societySkillFile(skill2.name);
     const replaced = await exists(file);
     const taken = proposal2.skillFiles;
-    const staged = path6.join(this.paths.proposalFiles(proposal2.id), "SKILL.md");
-    if (skill2.body === void 0 && (taken === void 0 || !await exists(staged))) {
+    const staged = path7.join(this.paths.proposalFiles(proposal2.id), "SKILL.md");
+    if (taken === void 0 || !await exists(staged)) {
       throw new BoardError("INVALID_STATE", `proposal ${proposal2.id} holds no skill files`);
     }
     await rm2(dir, { recursive: true, force: true });
-    if (skill2.body === void 0) {
-      await cp(this.paths.proposalFiles(proposal2.id), dir, { recursive: true });
-    } else {
-      await ensureDir(dir);
-    }
-    const body = skill2.body ?? (await readLooseMarkdown(file)).body;
+    await cp(this.paths.proposalFiles(proposal2.id), dir, { recursive: true });
+    const { body } = await readLooseMarkdown(file);
     await writeMarkdown(file, {
       name: skill2.name,
       description: skill2.summary,
@@ -7653,7 +7493,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
         proposedBy: proposal2.proposedBy,
         promotedBy: by,
         promotedAt: this.now().toISOString(),
-        ...taken === void 0 ? {} : { commit: taken.commit }
+        commit: taken.commit
       }
     }, body);
     await this.events.append("skill.promoted", by, {
@@ -7661,7 +7501,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       summary: skill2.summary,
       proposedBy: proposal2.proposedBy,
       replaced,
-      ...taken === void 0 ? {} : { files: taken.files.length },
+      files: taken.files.length,
       ...meta
     });
     await this.appendMessage(SYSTEM_ACTOR.name, "general", `Skill ${skill2.name} ${replaced ? "updated in" : "promoted to"} the society: ${sentence(skill2.summary)}. Every citizen's skills index now lists it.`);
@@ -7698,8 +7538,8 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     const dir = this.paths.proposalFiles(proposal2.id);
     await rm2(dir, { recursive: true, force: true });
     for (const entry of taken.files) {
-      const target = path6.join(dir, ...entry.path.split("/"));
-      await ensureDir(path6.dirname(target));
+      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);
     }
@@ -7757,7 +7597,8 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     const where = {
       scope: turn2.project,
       ...turn2.thread === void 0 ? {} : { thread: turn2.thread },
-      ...turn2.channel === void 0 ? {} : { channel: turn2.channel }
+      ...turn2.channel === void 0 ? {} : { channel: turn2.channel },
+      ...turn2.place === void 0 ? {} : { place: turn2.place }
     };
     await this.mutex.run(async () => {
       for (const proposal2 of await this.listProposals()) {
@@ -7789,16 +7630,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`);
@@ -7929,7 +7779,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     this.assertNoTurnCut(actor, `${ref} cannot be archived`, (turn2) => turn2.channel === channel && turn2.scope === scope || turn2.thread !== void 0 && closing.has(turn2.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;
       }
@@ -8035,7 +7885,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.
    */
@@ -8060,7 +7911,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;
       }
@@ -8078,7 +7929,7 @@ ${charter.purpose}
       });
       threadsClosed.push(doc.data.id);
     }
-    await this.endCronsUnlocked(by, `project ${slug} was archived`, (cron2) => cron2.scope === slug || cron2.thread !== void 0 && threadsClosed.includes(cron2.thread));
+    await this.endCronsUnlocked(by, `project ${slug} was archived`, (cron2) => cron2.scope === slug || cron2.place === slug || cron2.thread !== void 0 && threadsClosed.includes(cron2.thread));
     const project2 = await this.updateProject(slug, (p) => ({
       ...p,
       members: [],
@@ -8135,10 +7986,10 @@ ${charter.purpose}
         ...project2,
         members: project2.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);
@@ -8218,6 +8069,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.
@@ -8328,6 +8190,7 @@ ${charter.purpose}
       await this.validateProvision(filed.kind, filed.charter);
     }
     this.assertNoTurnCut(actor, `proposal ${proposalId} cannot be decided`, (turn2) => turn2.thread === proposalId);
+    const thread2 = await this.proposalThreadUnlocked(filed);
     if (outcome === "approved" && filed.kind === "archive") {
       await this.assertProjectQuiet(actor, ArchiveProposalSchema.parse(filed.charter).project);
     }
@@ -8369,7 +8232,6 @@ ${charter.purpose}
     const verdict = outcome === "approved" ? "Approved" : "Rejected";
     const why = reason === void 0 ? "" : ` Reason: ${reason}.`;
     const result = provision === void 0 ? "" : ` Provisioned: ${Object.entries(provision).map(([key, value]) => `${key} ${plain(value)}`).join(", ")}.`;
-    const thread2 = await this.proposalThreadUnlocked(actor.name, proposal2);
     const post = `${verdict}: ${describeCharter(proposal2.kind, proposal2.charter)}.${why}${result}`;
     await this.appendThreadMessage(actor.name, thread2.id, actor.name === SYSTEM_ACTOR.name ? withoutMentions(post) : post, { step: { action: outcome } });
     await this.endThreadOf(proposalId, actor.name, outcome);
@@ -8468,7 +8330,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;
@@ -8525,7 +8387,7 @@ function globals() {
 function print(value, human) {
   console.log(globals().json ? JSON.stringify(value, null, 2) : human());
 }
-async function open2() {
+async function open3() {
   return Board.open(globals().data);
 }
 async function actorFor(board, as) {
@@ -8571,7 +8433,7 @@ user.command("token").description("Issue the user a new token and print it once;
   if (!opts.rotate) {
     throw new BoardError("VALIDATION", "the board keeps only a hash of the user token, so it cannot show it again; `user token --rotate` issues a new one");
   }
-  const board = await open2();
+  const board = await open3();
   const userToken = await board.rotateUserToken();
   print({ userToken }, () => [
     `User token (shown once): ${userToken}`,
@@ -8580,7 +8442,7 @@ user.command("token").description("Issue the user a new token and print it once;
 });
 var project = program.command("project").description("Manage projects");
 project.command("add <slug>").description("Add a project with its default channels").option("--name <name>", "display name").option("--repo <url>", "git remote").option("--on-done <effect>", "what finishing a task does: none, or merge its branch").action(async (slug, opts) => {
-  const board = await open2();
+  const board = await open3();
   const added = await board.addProject(board.userActor(), {
     slug,
     name: opts.name,
@@ -8590,7 +8452,7 @@ project.command("add <slug>").description("Add a project with its default channe
   print(added, () => `Project ${added.slug} added with channels ${added.channels.join(", ")}`);
 });
 project.command("configure <slug>").description("Set a project's completion effect").requiredOption("--on-done <effect>", "none, or merge").option("--as <agent>", "act as this agent instead of the user").action(async (slug, opts) => {
-  const board = await open2();
+  const board = await open3();
   const configured = await board.configureProject(await actorFor(board, opts.as), {
     project: slug,
     on_done: CompletionEffectSchema.parse(opts.onDone)
@@ -8598,7 +8460,7 @@ project.command("configure <slug>").description("Set a project's completion effe
   print(configured, () => `Project ${configured.slug}: on done ${configured.onDone}`);
 });
 project.command("archive <slug>").description("Archive a project with no task in play: its members leave and its threads close").requiredOption("--reason <text>", "why the project is archived").action(async (slug, opts) => {
-  const board = await open2();
+  const board = await open3();
   const archived = await board.archiveProject(board.userActor(), {
     project: slug,
     reason: opts.reason
@@ -8606,13 +8468,13 @@ project.command("archive <slug>").description("Archive a project with no task in
   print(archived, () => `Project ${archived.slug} archived`);
 });
 project.command("list").description("List projects").action(async () => {
-  const board = await open2();
+  const board = await open3();
   const projects = await board.listProjects();
   print(projects, () => projects.map((p) => p.archived === void 0 ? `${p.slug}	${p.name}	members: ${p.members.join(", ") || "none"}` : `${p.slug}	${p.name}	archived ${p.archived.at} by ${p.archived.by}`).join("\n"));
 });
 var runner = program.command("runner").description("Manage runners");
 runner.command("add <name>").description("Register a runner and print its token once").action(async (name) => {
-  const board = await open2();
+  const board = await open3();
   const { runner: added, token } = await board.addRunner(board.userActor(), name);
   print({ runner: added, token }, () => [
     `Runner ${added.name} added`,
@@ -8621,13 +8483,13 @@ runner.command("add <name>").description("Register a runner and print its token
   ].join("\n"));
 });
 runner.command("list").description("List runners and what they offer").action(async () => {
-  const board = await open2();
+  const board = await open3();
   const runners = await board.listRunners();
   print(runners, () => runners.length === 0 ? "No runners yet; add one with `runner add <name>`." : runners.map((each) => `${each.name}  ${each.status}  ${each.os}${each.version === void 0 ? "" : `  v${each.version}`}  ${each.clis.join(",") || "no CLIs yet"}${each.capabilities.length === 0 ? "" : `  ${each.capabilities.join(",")}`}`).join("\n"));
 });
 var agent = program.command("agent").description("Manage agents");
 agent.command("add <name>").description("Add an agent and print its board token once").requiredOption("--role <role>", "role charter name").option("--cli <cli>", "claude or codex").option("--model <model>", "model to run the CLI with; the CLI's own default otherwise").option("--runner <name>", "runner preferred for its turns; any with its CLI otherwise").option("-p, --project <slug...>", "project memberships").action(async (name, opts) => {
-  const board = await open2();
+  const board = await open3();
   const cli = opts.cli === void 0 ? null : CliKindSchema.parse(opts.cli);
   const { agent: added, token } = await board.addAgent(board.userActor(), {
     name,
@@ -8640,7 +8502,7 @@ agent.command("add <name>").description("Add an agent and print its board token
   print({ agent: added, token }, () => [`Agent ${added.name} added as ${added.role}`, `Token (shown once): ${token}`].join("\n"));
 });
 agent.command("runner <name> [runner]").description("Show or set the runner a citizen's work outside any project runs on; `none` pins it again on its next turn").action(async (name, chosen) => {
-  const board = await open2();
+  const board = await open3();
   if (chosen === void 0) {
     const current = await board.readAgent(name);
     print({ agent: name, homeRunner: current.homeRunner ?? null }, () => current.homeRunner === void 0 ? `${name} is not pinned; its next turn outside a project pins it` : `${name} runs on ${current.homeRunner}`);
@@ -8650,7 +8512,7 @@ agent.command("runner <name> [runner]").description("Show or set the runner a ci
   print({ agent: name, homeRunner: updated.homeRunner ?? null }, () => updated.homeRunner === void 0 ? `${name} will be pinned on its next turn` : `${name} runs on ${updated.homeRunner} from its next turn`);
 });
 agent.command("list").description("List agents").action(async () => {
-  const board = await open2();
+  const board = await open3();
   const agents = await board.listAgents();
   const members = await board.listMembers();
   print(agents, () => agents.map((a) => {
@@ -8659,28 +8521,28 @@ agent.command("list").description("List agents").action(async () => {
   }).join("\n"));
 });
 agent.command("model <name> [model]").description("Set the model a member's turns run with, from its next turn; no model means the CLI's default").action(async (name, model) => {
-  const board = await open2();
+  const board = await open3();
   const updated = await board.setAgentModel(board.userActor(), name, model ?? null);
   print(updated, () => `${updated.name} runs with ${updated.model ?? "its CLI's default model"} from its next turn`);
 });
 agent.command("effort <name> [effort]").description("Set the reasoning effort a member's turns run with, from its next turn, such as high; no effort means the model's default").action(async (name, effort) => {
-  const board = await open2();
+  const board = await open3();
   const updated = await board.setAgentEffort(board.userActor(), name, effort ?? null);
   print(updated, () => `${updated.name} runs with ${updated.effort === void 0 ? "its model's default effort" : `${updated.effort} effort`} from its next turn`);
 });
 agent.command("retire <name>").description("Retire a member: no more wakes, claims released, token revoked, sessions archived").requiredOption("--reason <text>", "why").action(async (name, opts) => {
-  const board = await open2();
+  const board = await open3();
   const retired = await board.retireAgent(board.userActor(), { name, reason: opts.reason });
   print(retired, () => `Agent ${retired.name} retired: ${opts.reason}`);
 });
 var proposal = program.command("proposal").description("Governance proposals");
 proposal.command("list").description("List proposals").action(async () => {
-  const board = await open2();
+  const board = await open3();
   const proposals = await board.listProposals();
   print(proposals, () => proposals.length === 0 ? "No proposals." : proposals.map((p) => `${p.id}	${p.kind}	${p.status}	by ${p.proposedBy}`).join("\n"));
 });
 proposal.command("show <id>").description("Show a proposal with its charter and rationale").action(async (id) => {
-  const board = await open2();
+  const board = await open3();
   const found = await board.readProposal(id);
   print(found, () => [
     `${found.id}  ${found.kind}  ${found.status}  by ${found.proposedBy}`,
@@ -8690,7 +8552,7 @@ proposal.command("show <id>").description("Show a proposal with its charter and
   ].filter((line) => line.length > 0).join("\n"));
 });
 proposal.command("create").description("Propose a member, role, channel, reallocation, or retirement").requiredOption("--kind <kind>", "member, role, channel, reallocation, or retirement").requiredOption("--charter <json>", "the charter as a JSON object").option("--rationale <text>", "why", "").option("--as <agent>", "act as this agent instead of the user").action(async (opts) => {
-  const board = await open2();
+  const board = await open3();
   const created = await board.propose(await actorFor(board, opts.as), {
     kind: ProposalKindSchema.parse(opts.kind),
     charter: parseCharter(opts.charter),
@@ -8699,7 +8561,7 @@ proposal.command("create").description("Propose a member, role, channel, realloc
   print(created, () => `Proposal ${created.id} (${created.kind}) is ${created.status}`);
 });
 proposal.command("approve <id>").description("Approve a proposal; the board provisions it").option("--reason <text>", "a note for the record").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
-  const board = await open2();
+  const board = await open3();
   const decision = await board.approve(await actorFor(board, opts.as), {
     proposal_id: id,
     ...opts.reason === void 0 ? {} : { reason: opts.reason }
@@ -8708,7 +8570,7 @@ proposal.command("approve <id>").description("Approve a proposal; the board prov
   print({ decision, proposal: after }, () => `Proposal ${id} approved; it is now ${after.status}`);
 });
 proposal.command("reject <id>").description("Reject a proposal with a reason").requiredOption("--reason <text>", "why").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
-  const board = await open2();
+  const board = await open3();
   const decision = await board.reject(await actorFor(board, opts.as), {
     proposal_id: id,
     reason: opts.reason
@@ -8717,14 +8579,14 @@ proposal.command("reject <id>").description("Reject a proposal with a reason").r
 });
 var role = program.command("role").description("Role charters");
 role.command("list").description("List role charters").action(async () => {
-  const board = await open2();
+  const board = await open3();
   const roles = await board.listRoles();
   print(roles, () => roles.map((r) => `${r.name}	replicas up to ${r.maxReplicas}	backlog threshold ${r.backlogThreshold}	wakes on ${r.wakeTriggers.join(", ") || "direct wakes only"}`).join("\n"));
 });
 role.command("add <name>").description("Write a new role charter directly as the user").requiredOption("--purpose <text>", "what the role is for; its members read this every turn").option("--verbs <verbs...>", "board verbs granted; the member verbs by default").option("--triggers <triggers...>", "wakes it opts into: user_post, ops_event, heartbeat", [
   "heartbeat"
 ]).action(async (name, opts) => {
-  const board = await open2();
+  const board = await open3();
   const added = await board.setRoleCharter(board.userActor(), {
     name,
     purpose: opts.purpose,
@@ -8734,7 +8596,7 @@ role.command("add <name>").description("Write a new role charter directly as the
   print(added, () => `Role ${added.name} written with ${added.verbs.length} verbs`);
 });
 role.command("set <name>").description("Change a charter directly as the user: scaling cap, threshold, or purpose").option("--max-replicas <n>", "active members of the role per project the scheduler may reach").option("--backlog-threshold <n>", "load per member that adds a replica").option("--purpose <text>", "the charter's purpose").action(async (name, opts) => {
-  const board = await open2();
+  const board = await open3();
   const current = await board.readRole(name);
   const updated = await board.setRoleCharter(board.userActor(), {
     ...current,
@@ -8746,7 +8608,7 @@ role.command("set <name>").description("Change a charter directly as the user: s
 });
 var channelCommand = program.command("channel").description("Channels");
 channelCommand.command("add <ref>").description("Open a channel: <name> for the society or <project>/<name>").requiredOption("--purpose <text>", "what the channel is for").option("--as <agent>", "act as this agent instead of the user").action(async (ref, opts) => {
-  const board = await open2();
+  const board = await open3();
   const parsed = parseChannelRef(ref);
   const added = await board.addChannel(await actorFor(board, opts.as), {
     project: parsed.project,
@@ -8756,7 +8618,7 @@ channelCommand.command("add <ref>").description("Open a channel: <name> for the
   print({ channel: added }, () => `Channel ${added} opened`);
 });
 channelCommand.command("archive <ref>").description("Archive a channel whose workstream is done, once no task filed there is in play").requiredOption("--reason <text>", "why its work is done").option("--as <agent>", "act as this agent instead of the user").action(async (ref, opts) => {
-  const board = await open2();
+  const board = await open3();
   const archived = await board.archiveChannel(await actorFor(board, opts.as), {
     channel: ref,
     reason: opts.reason
@@ -8764,12 +8626,12 @@ channelCommand.command("archive <ref>").description("Archive a channel whose wor
   print(archived, () => `Channel ${ref} archived: ${archived.reason}`);
 });
 program.command("signals").description("Recent operations signals, oldest first").option("--limit <n>", "how many", "50").action(async (opts) => {
-  const board = await open2();
+  const board = await open3();
   const signals = await board.listSignals(Number(opts.limit));
   print(signals, () => signals.length === 0 ? "No signals yet." : signals.map((s) => `[${s.ts}] ${s.signal.kind}	${s.signal.summary}`).join("\n"));
 });
 program.command("post <channel> <body>").description("Post a message to a channel, or into one of its threads").option("--as <agent>", "act as this agent instead of the user").option("--thread <threadId>", "post into the thread, which must hang off the channel").action(async (channel, body, opts) => {
-  const board = await open2();
+  const board = await open3();
   const who = await actorFor(board, opts.as);
   const message = await board.postMessage(who, {
     channel,
@@ -8779,13 +8641,13 @@ program.command("post <channel> <body>").description("Post a message to a channe
   print(message, () => `Posted ${message.id} to ${message.channel}${message.thread === void 0 ? "" : ` (thread ${message.thread})`}`);
 });
 program.command("ask <text>").description("Post to the society's general channel as the user; the front desk routes it").action(async (text) => {
-  const board = await open2();
+  const board = await open3();
   const message = await board.postMessage(board.userActor(), { channel: "general", body: text });
   print(message, () => `Posted ${message.id} to general; the concierge wakes on it`);
 });
 var task = program.command("task").description("Manage tasks");
 task.command("create <project> <title>").description("Create a task with a plan, or with one stage anyone in the project may take").option("--body <text>", "task body", "").option("--parent <id>", "parent task id").option("--plan <json>", `stages, for example '[{"name":"analysis","role":"analyst"}]'`).option("--channel <name>", "the project's channel to file it in, such as a release's", "general").option("--as <agent>", "act as this agent instead of the user").action(async (projectSlug, title, opts) => {
-  const board = await open2();
+  const board = await open3();
   const who = await actorFor(board, opts.as);
   const created = await board.createTask(who, {
     project: projectSlug,
@@ -8801,17 +8663,17 @@ task.command("create <project> <title>").description("Create a task with a plan,
   ].join("\n"));
 });
 task.command("claim <id>").description("Hold the task's current stage").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
-  const board = await open2();
+  const board = await open3();
   const claimed = await board.claimTask(await actorFor(board, opts.as), { task_id: id });
   print(claimed, () => `Stage ${claimed.stage} of task ${claimed.id} held by ${claimed.claimedBy ?? "?"} until ${claimed.leaseExpiresAt ?? "?"}`);
 });
 task.command("release <id>").description("Let go of the stage held on a task").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
-  const board = await open2();
+  const board = await open3();
   const released = await board.releaseTask(await actorFor(board, opts.as), { task_id: id });
   print(released, () => `Stage ${released.stage} of task ${released.id} released`);
 });
 task.command("advance <id>").description("Finish the current stage; past the last one the task is done").option("--note <text>", "what was done, posted to the task's thread").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
-  const board = await open2();
+  const board = await open3();
   const advanced = await board.advanceTask(await actorFor(board, opts.as), {
     task_id: id,
     ...opts.note === void 0 ? {} : { note: opts.note }
@@ -8820,7 +8682,7 @@ task.command("advance <id>").description("Finish the current stage; past the las
 ${describePlan(advanced)}`);
 });
 task.command("plan <id> <stages>").description("Reshape the stages ahead: pass existing stages with their id to keep them, new ones without").option("--on-done <effect>", "override the completion effect for this task").option("--as <agent>", "act as this agent instead of the user").action(async (id, stages, opts) => {
-  const board = await open2();
+  const board = await open3();
   const planned = await board.planTask(await actorFor(board, opts.as), {
     task_id: id,
     stages: PlanEditSchema.parse(JSON.parse(stages)),
@@ -8829,7 +8691,7 @@ task.command("plan <id> <stages>").description("Reshape the stages ahead: pass e
   print(planned, () => describePlan(planned));
 });
 task.command("update <id>").description("Send a task back to an earlier stage, abandon it, or set blockers, with a note for its thread").option("--stage <stageId>", "move back to this earlier stage").option("--abandon", "abandon the task", false).option("--note <text>", "a note, posted to the task's thread").option("--blocked-by <ids...>", "task ids this task waits on").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
-  const board = await open2();
+  const board = await open3();
   const updated = await board.updateTask(await actorFor(board, opts.as), {
     task_id: id,
     ...opts.stage === void 0 ? {} : { stage: opts.stage },
@@ -8840,7 +8702,7 @@ task.command("update <id>").description("Send a task back to an earlier stage, a
   print(updated, () => `Task ${updated.id} is ${updated.status} at ${updated.stage}`);
 });
 task.command("show <id>").description("Show a task with its plan and its thread").action(async (id) => {
-  const board = await open2();
+  const board = await open3();
   const found = await board.getTask(board.userActor(), { task_id: id });
   const threadState = await board.readThread(id).then((t) => t.state).catch(() => "none");
   const said = found.messages.map((message) => {
@@ -8860,7 +8722,7 @@ ${message.body.trim()}
   ].join("\n"));
 });
 task.command("list <project>").description("List a project's tasks with their current stage").action(async (projectSlug) => {
-  const board = await open2();
+  const board = await open3();
   const tasks = await board.listTasks(projectSlug);
   print(tasks, () => tasks.length === 0 ? "No tasks." : tasks.map((t) => {
     const stage = t.stages[stageIndex(t, t.stage)];
@@ -8868,18 +8730,16 @@ task.command("list <project>").description("List a project's tasks with their cu
   }).join("\n"));
 });
 var thread = program.command("thread").description("Manage threads");
-thread.command("open [taskId]").description("Open a thread on a task, on a proposal, or on a channel with a title").option("--proposal <id>", "open the proposal's thread").option("--channel <ref>", "the channel it hangs off; required for a topic").option("--title <text>", "the thread's title; required for a topic").option("--as <agent>", "act as this agent instead of the user").action(async (taskId, opts) => {
-  const board = await open2();
+thread.command("open").description("Open a thread on a channel with a title; a task's or a proposal's opens with it").requiredOption("--channel <ref>", "the channel it hangs off").requiredOption("--title <text>", "the thread's title").option("--as <agent>", "act as this agent instead of the user").action(async (opts) => {
+  const board = await open3();
   const opened = await board.openThread(await actorFor(board, opts.as), {
-    ...taskId === void 0 ? {} : { task_id: taskId },
-    ...opts.proposal === void 0 ? {} : { proposal_id: opts.proposal },
-    ...opts.channel === void 0 ? {} : { channel: opts.channel },
-    ...opts.title === void 0 ? {} : { title: opts.title }
+    channel: opts.channel,
+    title: opts.title
   });
   print(opened, () => `Thread ${opened.id} opened on ${opened.channel}: ${opened.title}`);
 });
 thread.command("close <threadId>").description("Close a thread with a summary posted to its channel").requiredOption("--summary <text>", "closure summary").option("--as <agent>", "act as this agent instead of the user").action(async (threadId, opts) => {
-  const board = await open2();
+  const board = await open3();
   const summary = await board.closeThread(await actorFor(board, opts.as), {
     thread_id: threadId,
     summary: opts.summary
@@ -8887,7 +8747,7 @@ thread.command("close <threadId>").description("Close a thread with a summary po
   print(summary, () => `Thread closed; summary posted as ${summary.id} to ${summary.channel}`);
 });
 thread.command("list").description("List threads, the society's first, then each project's").option("--open", "only open threads", false).action(async (opts) => {
-  const board = await open2();
+  const board = await open3();
   const threads = (await board.listThreads()).filter((t) => !opts.open || t.state === "open");
   print(threads, () => threads.length === 0 ? "No threads." : threads.map((t) => {
     const about = t.subject === void 0 ? "topic" : t.subject.kind;
@@ -8895,7 +8755,7 @@ thread.command("list").description("List threads, the society's first, then each
   }).join("\n"));
 });
 thread.command("show <threadId>").description("Show a thread and its messages").action(async (threadId) => {
-  const board = await open2();
+  const board = await open3();
   const found = await board.readThread(threadId);
   const messages = await board.listThread(threadId);
   print({ thread: found, messages }, () => [
@@ -8906,17 +8766,17 @@ thread.command("show <threadId>").description("Show a thread and its messages").
   ].join("\n"));
 });
 program.command("pause").description("Stop all wakeups; turns in flight finish").action(async () => {
-  const board = await open2();
+  const board = await open3();
   await board.setPaused(board.userActor(), true);
   print({ paused: true }, () => "Society paused");
 });
 program.command("resume").description("Allow wakeups again").action(async () => {
-  const board = await open2();
+  const board = await open3();
   await board.setPaused(board.userActor(), false);
   print({ paused: false }, () => "Society resumed");
 });
 program.command("society").description("The society's settings").command("timezone [zone]").description("Show the society's time zone, or set it: crons that name none are read in it").action(async (zone) => {
-  const board = await open2();
+  const board = await open3();
   const society = zone === void 0 ? await board.society() : await board.setTimezone(board.userActor(), zone);
   print({ timezone: society.timezone }, () => `Time zone: ${society.timezone}`);
 });
@@ -8924,7 +8784,8 @@ function describeCron(cron2, timeZone) {
   const where = [
     cron2.scope,
     cron2.thread,
-    cron2.channel === void 0 ? void 0 : `#${cron2.channel}`
+    cron2.channel === void 0 ? void 0 : `#${cron2.channel}`,
+    cron2.place === void 0 ? void 0 : `~${cron2.place}`
   ].filter((part) => part !== void 0).join("/");
   const next = nextFire(cron2, timeZone);
   const state = cron2.ended !== void 0 ? `ended (${cron2.ended.reason})` : cron2.paused !== void 0 ? "paused" : next === null ? "no time to come" : `next ${next.toISOString()}`;
@@ -8932,13 +8793,13 @@ function describeCron(cron2, timeZone) {
 }
 var cron = program.command("cron").description("Crons that wake citizens on a clock");
 cron.command("list").description("List crons, ended ones too with --all").option("--all", "include ended crons", false).action(async (opts) => {
-  const board = await open2();
+  const board = await open3();
   const { timezone } = await board.society();
   const crons = (await board.listCrons()).filter((each) => opts.all || each.ended === void 0);
   print(crons, () => crons.length === 0 ? "No crons." : crons.map((each) => describeCron(each, timezone)).join("\n"));
 });
 cron.command("add <agent> <title>").description("Set a cron that wakes a citizen, with a note on what to do then").requiredOption("--note <text>", "what the citizen does when it fires").option("--cron <expression>", "five fields: minute hour day-of-month month day-of-week").option("--timezone <zone>", "the zone the expression is read in; the society's otherwise").option("--at <time>", "one time to fire, with its offset, instead of --cron").option("--project <slug>", "where it fires: a project the citizen is in, or society").option("--thread <id>", "an open thread there whose conversation it fires in").option("--channel <name>", "an open channel there, other than general, whose conversation it fires in").option("--as <agent>", "act as this agent instead of the user").action(async (agentName, title, opts) => {
-  const board = await open2();
+  const board = await open3();
   const created = await board.createCron(await actorFor(board, opts.as), {
     title,
     note: opts.note,
@@ -8958,7 +8819,7 @@ for (const [name, paused] of [
   ["resume", false]
 ]) {
   cron.command(`${name} <id>`).description(paused ? "Pause a cron" : "Resume a paused cron from its next time").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
-    const board = await open2();
+    const board = await open3();
     const updated = await board.updateCron(await actorFor(board, opts.as), {
       cron_id: id,
       paused
@@ -8968,7 +8829,7 @@ for (const [name, paused] of [
   });
 }
 cron.command("remove <id>").description("End a cron for good").requiredOption("--reason <text>", "why it ends").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
-  const board = await open2();
+  const board = await open3();
   const removed = await board.removeCron(await actorFor(board, opts.as), {
     cron_id: id,
     reason: opts.reason
@@ -8977,12 +8838,12 @@ cron.command("remove <id>").description("End a cron for good").requiredOption("-
 });
 var knowledge = program.command("knowledge").description("Shared knowledge, by project or society");
 knowledge.command("list [project]").description("List knowledge topics of a project, or of the society when no project is given").action(async (projectSlug) => {
-  const board = await open2();
+  const board = await open3();
   const topics = await board.listKnowledge(projectSlug ?? null);
   print(topics, () => topics.length === 0 ? "No knowledge yet." : topics.map((t) => `${t.topic}	revision ${t.revision}, updated by ${t.updatedBy} at ${t.updatedAt}`).join("\n"));
 });
 knowledge.command("show <topic>").description("Print a knowledge topic").option("--project <slug>", "the project's topic instead of the society's").action(async (topic, opts) => {
-  const board = await open2();
+  const board = await open3();
   const found = (await board.listKnowledge(opts.project ?? null)).find((t) => t.topic === topic);
   if (found === void 0) {
     throw new BoardError("NOT_FOUND", `no knowledge topic ${topic}`);
@@ -8990,8 +8851,8 @@ knowledge.command("show <topic>").description("Print a knowledge topic").option(
   print(found, () => found.body);
 });
 knowledge.command("write <topic>").description("Write a knowledge topic as the user, from a file or standard input").requiredOption("--revision <n>", "the revision it replaces, as knowledge list shows it; 0 for a new topic").option("--project <slug>", "the project's topic instead of the society's").option("--file <path>", "read the body from this file instead of standard input").option("--as <agent>", "act as this agent instead of the user").action(async (topic, opts) => {
-  const board = await open2();
-  const body = opts.file === void 0 ? await readStdin() : await readFile5(path7.resolve(opts.file), "utf8");
+  const board = await open3();
+  const body = opts.file === void 0 ? await readStdin() : await readFile5(path8.resolve(opts.file), "utf8");
   const written = await board.writeKnowledge(await actorFor(board, opts.as), {
     project: opts.project ?? null,
     topic,
@@ -9002,7 +8863,7 @@ knowledge.command("write <topic>").description("Write a knowledge topic as the u
 });
 var skill = program.command("skill").description("Skills promoted to the society");
 skill.command("list").description("List the society's skills, and each member's own").action(async () => {
-  const board = await open2();
+  const board = await open3();
   const society = await board.listSocietySkills();
   const own = [];
   for (const member of await board.listAgents()) {
@@ -9017,7 +8878,7 @@ skill.command("list").description("List the society's skills, and each member's
   ].join("\n") || "No skills yet.");
 });
 skill.command("remove <name>").description("Remove a skill from the society's skills; its text is set aside, not destroyed").requiredOption("--reason <text>", "why it is wrong, superseded, or no longer used").option("--as <agent>", "act as this agent instead of the user").action(async (name, opts) => {
-  const board = await open2();
+  const board = await open3();
   const removed = await board.removeSkill(await actorFor(board, opts.as), {
     name,
     reason: opts.reason
@@ -9026,13 +8887,13 @@ skill.command("remove <name>").description("Remove a skill from the society's sk
 });
 var turn = program.command("turn").description("Turn operations");
 turn.command("digest <agent>").description("Show the unread messages the agent's next turn opens with, in one scope or all; the cursors stay put").option("--limit <n>", "maximum messages", "50").option("--project <slug>", "the scope whose turn to show: a project, or society").action(async (agentName, opts) => {
-  const board = await open2();
+  const board = await open3();
   const actor = await board.actorFor(agentName);
   const digest = await board.readDigest(opts.project === void 0 ? actor : { ...actor, scope: opts.project }, { advance: false, limit: Number(opts.limit) });
   print(digest, () => digest.messages.length === 0 ? "No unread messages." : digest.messages.map((m) => `[${m.ts}] ${m.channel}${m.thread === void 0 ? "" : ` (thread ${m.thread})`} @${m.author}: ${m.body.trim()}`).join("\n"));
 });
 turn.command("run <agent>").description("Enqueue a manual wake for an agent on a project, or a reflection turn").requiredOption("--project <slug>", "project to act on, or society for a society-scope turn").option("--reason <text>", "why", "manual wake from the admin CLI").option("--reflect", "a reflection turn instead of a working turn", false).action(async (agentName, opts) => {
-  const board = await open2();
+  const board = await open3();
   const event = await board.requestWake(board.userActor(), {
     agent: agentName,
     project: opts.project,