@kubitnodes/stellaris 0.3.22 → 0.3.24

package/dist/cli/index.js

@@ -2,14 +2,14 @@
 
 // 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 z15 } from "zod";
+import { z as z16 } from "zod";
 
 // packages/shared/dist/ids.js
 import { z } from "zod";
@@ -64,7 +64,8 @@ var VERB_NAMES = [
   "create_cron",
   "update_cron",
   "remove_cron",
-  "remove_skill"
+  "remove_skill",
+  "upload_image"
 ];
 var VerbNameSchema = z2.enum(VERB_NAMES);
 var CharterTriggerSchema = z2.enum(["user_post", "ops_event", "heartbeat"]);
@@ -93,6 +94,7 @@ var USER_ROLE = "user";
 var USER_NAME = "user";
 var MEMBER_VERBS = [
   "post_message",
+  "upload_image",
   "read_inbox",
   "search",
   "open_thread",
@@ -232,6 +234,7 @@ var CronFrontmatterSchema = z3.object({
   scope: NameSchema,
   thread: UlidSchema.optional(),
   channel: NameSchema.optional(),
+  place: NameSchema.optional(),
   schedule: CronScheduleSchema,
   createdBy: NameSchema,
   createdAt: IsoDateTimeSchema,
@@ -937,7 +940,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;
@@ -985,130 +989,169 @@ var DecisionSchema = z5.object({
 });
 
 // packages/shared/dist/verbs.js
+import { z as z7 } from "zod";
+
+// packages/shared/dist/images.js
 import { z as z6 } from "zod";
-var MomentSchema = z6.iso.datetime({ offset: true });
-var CronTitleSchema = z6.string().trim().min(1).max(120);
-var CronNoteSchema = z6.string().trim().min(1).max(4e3);
+var IMAGE_LIMIT_BYTES = 8 * 1024 * 1024;
+var ImageTypeSchema = z6.enum(["png", "jpeg", "gif", "webp"]);
+function startsWith(bytes, prefix, at = 0) {
+  for (let index = 0; index < prefix.length; index += 1) {
+    if (bytes[at + index] !== prefix[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+var ascii = (text) => new TextEncoder().encode(text);
+function imageTypeOf(bytes) {
+  if (startsWith(bytes, [137, 80, 78, 71, 13, 10, 26, 10])) {
+    return "png";
+  }
+  if (startsWith(bytes, [255, 216, 255])) {
+    return "jpeg";
+  }
+  if (startsWith(bytes, ascii("GIF87a")) || startsWith(bytes, ascii("GIF89a"))) {
+    return "gif";
+  }
+  if (startsWith(bytes, ascii("RIFF")) && startsWith(bytes, ascii("WEBP"), 8)) {
+    return "webp";
+  }
+  return null;
+}
+var ImagePathSchema = z6.string().min(1).max(4096).refine((value) => !value.includes("\0"), { message: "a path with no NUL character" });
+var IMAGE_SCHEME = "image:";
+var UploadedImageSchema = z6.object({
+  id: UlidSchema,
+  type: ImageTypeSchema,
+  size: z6.number().int().positive(),
+  markdown: z6.string()
+});
+
+// packages/shared/dist/verbs.js
+var MomentSchema = z7.iso.datetime({ offset: true });
+var CronTitleSchema = z7.string().trim().min(1).max(120);
+var CronNoteSchema = z7.string().trim().min(1).max(4e3);
 var VerbInputs = {
-  post_message: z6.object({
+  post_message: z7.object({
     /** Required outside a thread; in one it may be left out, and must otherwise be the thread's. */
     channel: ChannelRefSchema.optional(),
-    body: z6.string().min(1),
+    body: z7.string().min(1),
     thread_id: UlidSchema.optional()
   }),
-  read_inbox: z6.object({
+  read_inbox: z7.object({
     since_cursor: UlidSchema.nullable().optional(),
-    limit: z6.number().int().positive().max(200).default(50),
-    advance: z6.boolean().default(true)
+    limit: z7.number().int().positive().max(200).default(50),
+    advance: z7.boolean().default(true)
   }),
-  search: z6.object({
-    query: z6.string().min(1),
+  search: z7.object({
+    query: z7.string().min(1),
     project: NameSchema.optional(),
     channel: ChannelRefSchema.optional(),
-    limit: z6.number().int().positive().max(100).default(20)
+    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. */
-  open_thread: z6.object({
+  open_thread: z7.object({
     task_id: UlidSchema.optional(),
     proposal_id: UlidSchema.optional(),
     channel: ChannelRefSchema.optional(),
-    title: z6.string().min(1).max(200).optional()
+    title: z7.string().min(1).max(200).optional()
   }),
-  close_thread: z6.object({ thread_id: UlidSchema, summary: z6.string().min(1) }),
-  create_task: z6.object({
+  close_thread: z7.object({ thread_id: UlidSchema, summary: z7.string().min(1) }),
+  create_task: z7.object({
     project: NameSchema,
-    title: z6.string().min(1).max(200),
-    body: z6.string().default(""),
+    title: z7.string().min(1).max(200),
+    body: z7.string().default(""),
     parent_id: UlidSchema.optional(),
-    required_capabilities: z6.array(z6.string()).default([]),
+    required_capabilities: z7.array(z7.string()).default([]),
     /** The plan; without it the task gets one stage, work, that anyone in the project may take. */
-    stages: z6.array(PlanStageSchema).min(1).optional(),
+    stages: z7.array(PlanStageSchema).min(1).optional(),
     /** A channel of the project the task belongs to, such as a release's; its thread opens there. */
     channel: NameSchema.default("general")
   }),
-  claim_task: z6.object({ task_id: UlidSchema }),
-  release_task: z6.object({ task_id: UlidSchema }),
-  update_task: z6.object({
+  claim_task: z7.object({ task_id: UlidSchema }),
+  release_task: z7.object({ task_id: UlidSchema }),
+  update_task: z7.object({
     task_id: UlidSchema,
     /** Move the task back to this earlier stage. */
     stage: StageIdSchema.optional(),
-    status: z6.enum(["abandoned"]).optional(),
+    status: z7.enum(["abandoned"]).optional(),
     /** Posted to the task's thread as the caller, marked with the step when the task moved. */
-    note: z6.string().min(1).optional(),
-    blocked_by: z6.array(UlidSchema).optional(),
+    note: z7.string().min(1).optional(),
+    blocked_by: z7.array(UlidSchema).optional(),
     /**
      * The pull request a `ghpr` task lands through, on its project's repository, with the merge
      * commit's subject and body; null unlinks it.
      */
-    pull_request: z6.object({
+    pull_request: z7.object({
       url: PullRequestUrlSchema,
       merge_subject: MergeSubjectSchema.optional(),
-      merge_body: z6.string().max(2e4).optional()
+      merge_body: z7.string().max(2e4).optional()
     }).nullable().optional()
   }),
-  get_task: z6.object({ task_id: UlidSchema }),
-  subscribe: z6.object({ channel: ChannelRefSchema }),
-  unsubscribe: z6.object({ channel: ChannelRefSchema }),
-  propose: z6.object({
+  get_task: z7.object({ task_id: UlidSchema }),
+  subscribe: z7.object({ channel: ChannelRefSchema }),
+  unsubscribe: z7.object({ channel: ChannelRefSchema }),
+  propose: z7.object({
     kind: ProposalKindSchema,
-    charter: z6.record(z6.string(), z6.unknown()),
-    rationale: z6.string().default("")
+    charter: z7.record(z7.string(), z7.unknown()),
+    rationale: z7.string().default("")
   }),
-  approve: z6.object({ proposal_id: UlidSchema, reason: z6.string().optional() }),
-  reject: z6.object({ proposal_id: UlidSchema, reason: z6.string().min(1) }),
-  create_project: z6.object({
+  approve: z7.object({ proposal_id: UlidSchema, reason: z7.string().optional() }),
+  reject: z7.object({ proposal_id: UlidSchema, reason: z7.string().min(1) }),
+  create_project: z7.object({
     slug: NameSchema,
-    name: z6.string().min(1).optional(),
-    repo: z6.string().min(1).nullable().default(null),
+    name: z7.string().min(1).optional(),
+    repo: z7.string().min(1).nullable().default(null),
     default_branch: DefaultBranchSchema.default("main"),
     on_done: CompletionEffectSchema.optional()
   }),
-  join_project: z6.object({ project: NameSchema, agent: NameSchema.optional() }),
-  leave_project: z6.object({ project: NameSchema, agent: NameSchema.optional() }),
-  write_knowledge: z6.object({
+  join_project: z7.object({ project: NameSchema, agent: NameSchema.optional() }),
+  leave_project: z7.object({ project: NameSchema, agent: NameSchema.optional() }),
+  write_knowledge: z7.object({
     /** A project you belong to, or null for society knowledge, which the steward and the user curate. */
     project: NameSchema.nullable().default(null),
     topic: NameSchema,
-    body: z6.string().min(1),
+    body: z7.string().min(1),
     /** The `revision` in the frontmatter of the topic you read, 0 when it names none or for a new topic. */
-    revision: z6.number().int().min(0)
+    revision: z7.number().int().min(0)
   }),
-  remove_knowledge: z6.object({
+  remove_knowledge: z7.object({
     /** As for write_knowledge: a project you belong to, or null for society knowledge. */
     project: NameSchema.nullable().default(null),
     topic: NameSchema
   }),
-  plan_task: z6.object({
+  plan_task: z7.object({
     task_id: UlidSchema,
-    stages: z6.array(PlanEditStageSchema),
+    stages: z7.array(PlanEditStageSchema),
     on_done: CompletionEffectSchema.optional()
   }),
   /** The note is posted to the task's thread as the caller, marked with the step. */
-  advance_task: z6.object({ task_id: UlidSchema, note: z6.string().min(1).optional() }),
-  configure_project: z6.object({
+  advance_task: z7.object({ task_id: UlidSchema, note: z7.string().min(1).optional() }),
+  configure_project: z7.object({
     project: NameSchema,
     on_done: CompletionEffectSchema.optional(),
     /** A new display name; the slug, which everything refers to the project by, never changes. */
-    name: z6.string().trim().min(1).max(120).optional(),
+    name: z7.string().trim().min(1).max(120).optional(),
     /** The branch tasks start from and land on from now; tasks in play keep their branches. */
     default_branch: DefaultBranchSchema.optional()
   }),
-  archive_project: z6.object({ project: NameSchema, reason: z6.string().min(1) }),
-  create_channel: z6.object({
+  archive_project: z7.object({ project: NameSchema, reason: z7.string().min(1) }),
+  create_channel: z7.object({
     /** A project, or null for a channel of the society. */
     project: NameSchema.nullable().default(null),
     name: NameSchema,
-    purpose: z6.string().min(1)
+    purpose: z7.string().min(1)
   }),
-  archive_channel: z6.object({ channel: ChannelRefSchema, reason: z6.string().min(1) }),
-  update_dashboard: z6.object({
+  archive_channel: z7.object({ channel: ChannelRefSchema, reason: z7.string().min(1) }),
+  update_dashboard: z7.object({
     project: NameSchema,
     /** The whole dashboard as markdown; the board keeps its frontmatter. */
-    body: z6.string().min(1),
+    body: z7.string().min(1),
     /** The `revision` in the frontmatter of the dashboard you read, 0 when it names none. */
-    revision: z6.number().int().min(0)
+    revision: z7.number().int().min(0)
   }),
-  create_cron: z6.object({
+  create_cron: z7.object({
     title: CronTitleSchema,
     /** What to do when it fires; quoted in the prompt of every turn it starts. */
     note: CronNoteSchema,
@@ -1127,10 +1170,10 @@ var VerbInputs = {
     /** An open channel of that place other than general, whose conversation it fires in. */
     channel: NameSchema.optional()
   }),
-  update_cron: z6.object({
+  update_cron: z7.object({
     cron_id: UlidSchema,
     /** Pause it, or resume it, which starts its schedule afresh from now. */
-    paused: z6.boolean().optional(),
+    paused: z7.boolean().optional(),
     title: CronTitleSchema.optional(),
     note: CronNoteSchema.optional(),
     /** A new expression, or `at` for one time; either starts the schedule afresh. */
@@ -1139,12 +1182,16 @@ var VerbInputs = {
     timezone: TimeZoneSchema.nullable().optional(),
     at: MomentSchema.optional()
   }),
-  remove_cron: z6.object({ cron_id: UlidSchema, reason: z6.string().trim().min(1) }),
-  remove_skill: z6.object({ name: NameSchema, reason: z6.string().trim().min(1) })
+  remove_cron: z7.object({ cron_id: UlidSchema, reason: z7.string().trim().min(1) }),
+  remove_skill: z7.object({ name: NameSchema, reason: z7.string().trim().min(1) }),
+  upload_image: z7.object({
+    /** The image file on the machine your turn runs on: absolute, or relative to your working directory. */
+    path: ImagePathSchema
+  })
 };
 
 // packages/shared/dist/events.js
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var BOARD_EVENT_TYPES = [
   "society.initialized",
   "project.added",
@@ -1208,21 +1255,22 @@ var BOARD_EVENT_TYPES = [
   "cron.updated",
   "cron.fired",
   "cron.skipped",
-  "cron.ended"
+  "cron.ended",
+  "image.uploaded"
 ];
-var BoardEventTypeSchema = z7.enum(BOARD_EVENT_TYPES);
-var BoardEventSchema = z7.object({
+var BoardEventTypeSchema = z8.enum(BOARD_EVENT_TYPES);
+var BoardEventSchema = z8.object({
   id: UlidSchema,
   ts: IsoDateTimeSchema,
   type: BoardEventTypeSchema,
   actor: NameSchema,
-  payload: z7.record(z7.string(), z7.unknown())
+  payload: z8.record(z8.string(), z8.unknown())
 });
-var UsageSchema = z7.object({
-  inputTokens: z7.number().int().nonnegative(),
-  outputTokens: z7.number().int().nonnegative(),
-  cacheReadTokens: z7.number().int().nonnegative().default(0),
-  cacheWriteTokens: z7.number().int().nonnegative().default(0)
+var UsageSchema = z8.object({
+  inputTokens: z8.number().int().nonnegative(),
+  outputTokens: z8.number().int().nonnegative(),
+  cacheReadTokens: z8.number().int().nonnegative().default(0),
+  cacheWriteTokens: z8.number().int().nonnegative().default(0)
 });
 function addUsage(a, b) {
   return {
@@ -1232,14 +1280,14 @@ function addUsage(a, b) {
     cacheWriteTokens: a.cacheWriteTokens + b.cacheWriteTokens
   };
 }
-var TurnStatusSchema = z7.object({
-  summary: z7.string().min(1),
-  claimsHeld: z7.array(UlidSchema).default([]),
-  blockedOn: z7.array(z7.string()).default([]),
-  needsUserDecision: z7.boolean().default(false),
-  memoryUpdated: z7.boolean().default(false)
-});
-var TurnExitReasonSchema = z7.enum([
+var TurnStatusSchema = z8.object({
+  summary: z8.string().min(1),
+  claimsHeld: z8.array(UlidSchema).default([]),
+  blockedOn: z8.array(z8.string()).default([]),
+  needsUserDecision: z8.boolean().default(false),
+  memoryUpdated: z8.boolean().default(false)
+});
+var TurnExitReasonSchema = z8.enum([
   "completed",
   "timeout",
   "error",
@@ -1247,50 +1295,51 @@ var TurnExitReasonSchema = z7.enum([
   "blocked",
   "stopped"
 ]);
-var AgentEventSchema = z7.discriminatedUnion("type", [
-  z7.object({
-    type: z7.literal("turn_started"),
+var ResumeFailureSchema = z8.enum(["lost", "retry"]);
+var AgentEventSchema = z8.discriminatedUnion("type", [
+  z8.object({
+    type: z8.literal("turn_started"),
     agent: NameSchema,
-    session: z7.string(),
+    session: z8.string(),
     runner: NameSchema,
     /** The model the CLI reports running, when it reports one. */
-    model: z7.string().optional()
+    model: z8.string().optional()
   }),
   /**
    * The CLI took a steer into the running turn. Adapters name the steer; the server adds the
    * messages it delivered and the text the CLI was given.
    */
-  z7.object({
-    type: z7.literal("steered"),
-    steer: z7.string().min(1),
-    messages: z7.array(UlidSchema).optional(),
-    text: z7.string().optional()
+  z8.object({
+    type: z8.literal("steered"),
+    steer: z8.string().min(1),
+    messages: z8.array(UlidSchema).optional(),
+    text: z8.string().optional()
   }),
-  z7.object({ type: z7.literal("text"), delta: z7.string() }),
-  z7.object({ type: z7.literal("tool_call"), name: z7.string(), input: z7.unknown() }),
-  z7.object({
-    type: z7.literal("tool_result"),
-    name: z7.string(),
-    ok: z7.boolean(),
+  z8.object({ type: z8.literal("text"), delta: z8.string() }),
+  z8.object({ type: z8.literal("tool_call"), name: z8.string(), input: z8.unknown() }),
+  z8.object({
+    type: z8.literal("tool_result"),
+    name: z8.string(),
+    ok: z8.boolean(),
     /** What the tool returned, cut to `OUTPUT_LIMIT` characters by `capOutput`. */
-    output: z7.string().optional()
+    output: z8.string().optional()
   }),
-  z7.object({ type: z7.literal("approval_requested"), kind: z7.string(), detail: z7.unknown() }),
-  z7.object({
-    type: z7.literal("turn_completed"),
+  z8.object({ type: z8.literal("approval_requested"), kind: z8.string(), detail: z8.unknown() }),
+  z8.object({
+    type: z8.literal("turn_completed"),
     usage: UsageSchema,
-    costUsd: z7.number().nonnegative(),
+    costUsd: z8.number().nonnegative(),
     status: TurnStatusSchema.nullable(),
     exitReason: TurnExitReasonSchema
   }),
-  z7.object({ type: z7.literal("error"), message: z7.string() })
+  z8.object({ type: z8.literal("error"), message: z8.string() })
 ]);
-var TranscriptEntrySchema = z7.object({
+var TranscriptEntrySchema = z8.object({
   ts: IsoDateTimeSchema,
   event: AgentEventSchema
 });
-var LiveTurnEventSchema = z7.object({
-  seq: z7.number().int().positive(),
+var LiveTurnEventSchema = z8.object({
+  seq: z8.number().int().positive(),
   ts: IsoDateTimeSchema,
   agent: NameSchema,
   project: NameSchema,
@@ -1298,243 +1347,280 @@ var LiveTurnEventSchema = z7.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
 });
 
 // packages/shared/dist/turns.js
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // packages/shared/dist/runner.js
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var HOME_SCRATCH = "scratch";
 var HOME_FILE_LIMIT_BYTES = 8 * 1024 * 1024;
-var RunnerHelloSchema = z8.object({
-  protocol: z8.number().int().positive(),
-  version: z8.string().min(1),
+var RunnerHelloSchema = z9.object({
+  protocol: z9.number().int().positive(),
+  version: z9.string().min(1),
   os: RunnerOsSchema,
-  clis: z8.array(CliKindSchema),
+  clis: z9.array(CliKindSchema),
   /** The CLIs whose adapter can keep a session warm between turns. */
-  residentClis: z8.array(CliKindSchema).default([]),
+  residentClis: z9.array(CliKindSchema).default([]),
   /** The CLIs whose adapter can take input into a running turn; the server steers only these. */
-  steerableClis: z8.array(CliKindSchema).default([]),
+  steerableClis: z9.array(CliKindSchema).default([]),
   /** The CLIs whose adapter can stop a running turn; the server stops only these. */
-  stoppableClis: z8.array(CliKindSchema).default([]),
+  stoppableClis: z9.array(CliKindSchema).default([]),
   /** Whether the runner answers file reads on its projects' branches; one from before never does. */
-  branchReads: z8.boolean().default(false),
+  branchReads: z9.boolean().default(false),
   /** Whether the runner lists what a branch changed; one from before never does. */
-  branchChanges: z8.boolean().default(false),
+  branchChanges: z9.boolean().default(false),
   /** Whether the runner answers a read of a CLI's quota; one from before never does. */
-  quotaReads: z8.boolean().default(false),
-  capabilities: z8.array(z8.string()).default([]),
+  quotaReads: z9.boolean().default(false),
+  /** Whether the runner reads an image a turn running there uploads; one from before never does. */
+  imageReads: z9.boolean().default(false),
+  capabilities: z9.array(z9.string()).default([]),
   /**
    * What the runner's account lacks of the git identity citizens' own commits carry, checked
    * before each hello outside any repository; empty when it has both. Absent from a runner from
    * before the check, which no default fills in, so the board marks only what a runner reported.
    */
-  gitIdentityMissing: z8.array(GitIdentityPartSchema).optional(),
+  gitIdentityMissing: z9.array(GitIdentityPartSchema).optional(),
   /** Turns the runner runs at once, or null for no limit. */
-  slots: z8.number().int().positive().nullable(),
+  slots: z9.number().int().positive().nullable(),
   /** Turns the runner is still running, when it registers again; the server fails the rest of its turns. */
-  turns: z8.array(UlidSchema).default([])
+  turns: z9.array(UlidSchema).default([])
 });
-var RunnerWelcomeSchema = z8.object({ name: NameSchema, version: z8.string() });
-var RunnerEnrollRequestSchema = z8.object({
-  protocol: z8.number().int().positive(),
-  version: z8.string().min(1).max(64),
-  hostname: z8.string().min(1).max(253),
+var RunnerWelcomeSchema = z9.object({ name: NameSchema, version: z9.string() });
+var RunnerEnrollRequestSchema = z9.object({
+  protocol: z9.number().int().positive(),
+  version: z9.string().min(1).max(64),
+  hostname: z9.string().min(1).max(253),
   os: RunnerOsSchema,
-  clis: z8.array(CliKindSchema).max(8),
-  capabilities: z8.array(z8.string().min(1).max(64)).max(32).default([])
+  clis: z9.array(CliKindSchema).max(8),
+  capabilities: z9.array(z9.string().min(1).max(64)).max(32).default([])
 });
-var RunnerEnrollmentSchema = z8.object({
-  deviceCode: z8.string().min(1),
-  userCode: z8.string().min(1),
+var RunnerEnrollmentSchema = z9.object({
+  deviceCode: z9.string().min(1),
+  userCode: z9.string().min(1),
   expiresAt: IsoDateTimeSchema,
-  intervalMs: z8.number().int().positive()
+  intervalMs: z9.number().int().positive()
 });
-var RunnerEnrollPollSchema = z8.object({ deviceCode: z8.string().min(1) });
-var RunnerEnrollStatusSchema = z8.discriminatedUnion("status", [
-  z8.object({ status: z8.literal("pending") }),
-  z8.object({ status: z8.literal("approved"), name: NameSchema, token: z8.string().min(1) }),
-  z8.object({ status: z8.literal("denied") })
+var RunnerEnrollPollSchema = z9.object({ deviceCode: z9.string().min(1) });
+var RunnerEnrollStatusSchema = z9.discriminatedUnion("status", [
+  z9.object({ status: z9.literal("pending") }),
+  z9.object({ status: z9.literal("approved"), name: NameSchema, token: z9.string().min(1) }),
+  z9.object({ status: z9.literal("denied") })
 ]);
-var PendingEnrollmentSchema = z8.object({
-  userCode: z8.string().min(1),
-  hostname: z8.string(),
+var PendingEnrollmentSchema = z9.object({
+  userCode: z9.string().min(1),
+  hostname: z9.string(),
   os: RunnerOsSchema,
-  clis: z8.array(CliKindSchema),
-  capabilities: z8.array(z8.string()),
-  version: z8.string(),
+  clis: z9.array(CliKindSchema),
+  capabilities: z9.array(z9.string()),
+  version: z9.string(),
   requestedAt: IsoDateTimeSchema,
   expiresAt: IsoDateTimeSchema
 });
-var ProjectRepoSchema = z8.object({
+var ProjectRepoSchema = z9.object({
   slug: NameSchema,
-  origin: z8.string().nullable(),
-  defaultBranch: z8.string().min(1),
+  origin: z9.string().nullable(),
+  defaultBranch: z9.string().min(1),
   /**
    * The board lands finished tasks on the default branch, itself or through their pull requests,
    * so the runner lets nothing else move it.
    */
-  boardLands: z8.boolean()
+  boardLands: z9.boolean()
 });
-var TurnWorkspaceSchema = z8.discriminatedUnion("kind", [
-  z8.object({
-    kind: z8.literal("home"),
+var TurnWorkspaceSchema = z9.discriminatedUnion("kind", [
+  z9.object({
+    kind: z9.literal("home"),
     thread: UlidSchema.optional(),
-    channel: NameSchema.optional()
+    channel: NameSchema.optional(),
+    place: NameSchema.optional()
   }),
-  z8.object({
-    kind: z8.literal("project"),
+  z9.object({
+    kind: z9.literal("project"),
     repo: ProjectRepoSchema,
-    branches: z8.array(z8.string().min(1)),
+    branches: z9.array(z9.string().min(1)),
     thread: UlidSchema.optional(),
     channel: NameSchema.optional()
   }),
-  z8.object({ kind: z8.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 = z8.object({
+var TurnJobSchema = z9.object({
   turnId: UlidSchema,
   agent: NameSchema,
   role: NameSchema,
   cli: CliKindSchema,
-  model: z8.string().optional(),
+  model: z9.string().optional(),
   /** The reasoning effort set on the agent; absent for the model's own default. */
-  effort: z8.string().optional(),
+  effort: z9.string().optional(),
   /** A project slug, or the society scope. */
   scope: NameSchema,
   /** The thread whose conversation the turn is in; absent for the home conversation. */
   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.
    */
-  session: z8.string().min(1).nullable(),
+  session: z9.string().min(1).nullable(),
   /** The running total the session reported after its last turn, which a resumed session starts from. */
-  costSoFarUsd: z8.number().nonnegative(),
+  costSoFarUsd: z9.number().nonnegative(),
   /** The rendered charter, norms, memory core, and skills index, with `PATH_TOKENS` for places. */
-  instructions: z8.string(),
-  prompt: z8.string(),
-  mcp: z8.object({ url: z8.string().min(1), token: z8.string().min(1) }),
-  limits: z8.object({
-    timeoutMs: z8.number().int().positive().nullable(),
-    maxTurns: z8.number().int().positive().nullable()
+  instructions: z9.string(),
+  prompt: z9.string(),
+  mcp: z9.object({ url: z9.string().min(1), token: z9.string().min(1) }),
+  limits: z9.object({
+    timeoutMs: z9.number().int().positive().nullable(),
+    maxTurns: z9.number().int().positive().nullable()
   }),
   /** Present when the runner keeps the conversation's session warm between turns, under `key`. */
-  resident: z8.object({ key: z8.string().min(1), idleMs: z8.number().int().positive() }).optional(),
+  resident: z9.object({ key: z9.string().min(1), idleMs: z9.number().int().positive() }).optional(),
   workspace: TurnWorkspaceSchema
 });
-var TurnWorkSchema = z8.object({ branch: z8.string().min(1), head: z8.string().min(1) });
-var TurnEventsSchema = z8.object({ entries: z8.array(TranscriptEntrySchema) });
-var TurnOutcomeSchema = z8.object({
+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,
   status: TurnStatusSchema.nullable(),
-  error: z8.string().nullable(),
+  error: z9.string().nullable(),
   usage: UsageSchema,
-  costUsd: z8.number().nonnegative(),
+  costUsd: z9.number().nonnegative(),
   /** The session's running total after this turn, for CLIs that report one. */
-  sessionCostUsd: z8.number().nonnegative().optional(),
-  /** The session the CLI used, which differs from the job's for CLIs that assign their own ids. */
-  session: z8.string().min(1),
+  sessionCostUsd: z9.number().nonnegative().optional(),
+  /**
+   * 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(),
   /** The model the CLI reported, when it reported one. */
-  model: z8.string().nullable(),
+  model: z9.string().nullable(),
   work: TurnWorkSchema.nullable(),
   /**
    * Whether the turn's own workspace, a thread's, a channel's, or a task's, holds work on no
    * branch after the hand-back: uncommitted changes, or commits no branch contains.
    */
-  leftovers: z8.boolean().default(false),
+  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.
    */
   quota: CliQuotaSchema.optional()
 });
-var TurnAckSchema = z8.object({ dropWorkspace: z8.boolean() });
-var LandRequestSchema = z8.object({
+var TurnAckSchema = z9.object({ dropWorkspace: z9.boolean() });
+var LandRequestSchema = z9.object({
   repo: ProjectRepoSchema,
-  branch: z8.string().min(1),
+  branch: z9.string().min(1),
   /**
    * For a `ghpr` task, the pull request to merge in place of the branch, which must hold the
    * branch's files, and the merge commit's subject and body, the pull request's title and an
    * empty body when left out.
    */
-  pullRequest: z8.object({
-    url: z8.string().min(1),
-    subject: z8.string().min(1).optional(),
-    body: z8.string().optional()
+  pullRequest: z9.object({
+    url: z9.string().min(1),
+    subject: z9.string().min(1).optional(),
+    body: z9.string().optional()
   }).optional()
 });
-var CloseRequestSchema = z8.object({
+var CloseRequestSchema = z9.object({
   repo: ProjectRepoSchema,
-  url: z8.string().min(1),
-  comment: z8.string().min(1)
+  url: z9.string().min(1),
+  comment: z9.string().min(1)
 });
-var MergeOutcomeSchema = z8.object({ ok: z8.boolean(), detail: z8.string() });
-var ModelListSchema = z8.array(ModelOptionSchema);
+var MergeOutcomeSchema = z9.object({ ok: z9.boolean(), detail: z9.string() });
+var ModelListSchema = z9.array(ModelOptionSchema);
 var BRANCH_FILE_LIMIT_BYTES = 8 * 1024 * 1024;
-var BranchPathSchema = z8.string().max(4096).refine((value) => value === "" || value.split("/").every((segment) => segment !== "" && segment !== "." && segment !== ".." && !segment.includes("\0")), { message: "a path inside the branch, with no empty, `.`, or `..` segment" });
-var BranchNameSchema = z8.string().regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/);
-var BranchReadSchema = z8.object({
+var BranchPathSchema = z9.string().max(4096).refine((value) => value === "" || value.split("/").every((segment) => segment !== "" && segment !== "." && segment !== ".." && !segment.includes("\0")), { message: "a path inside the branch, with no empty, `.`, or `..` segment" });
+var BranchNameSchema = z9.string().regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/);
+var BranchReadSchema = z9.object({
   repo: ProjectRepoSchema,
   branch: BranchNameSchema,
   path: BranchPathSchema
 });
-var BranchCommitSchema = z8.object({
-  id: z8.string().min(1),
+var BranchCommitSchema = z9.object({
+  id: z9.string().min(1),
   at: IsoDateTimeSchema,
-  author: z8.string()
+  author: z9.string()
 });
-var BranchFileSchema = z8.discriminatedUnion("kind", [
-  z8.object({
-    kind: z8.literal("file"),
+var BranchFileSchema = z9.discriminatedUnion("kind", [
+  z9.object({
+    kind: z9.literal("file"),
     path: BranchPathSchema,
     commit: BranchCommitSchema,
-    size: z8.number().int().nonnegative(),
-    content: z8.string().nullable()
+    size: z9.number().int().nonnegative(),
+    content: z9.string().nullable()
   }),
-  z8.object({
-    kind: z8.literal("dir"),
+  z9.object({
+    kind: z9.literal("dir"),
     path: BranchPathSchema,
     commit: BranchCommitSchema,
-    entries: z8.array(z8.object({
-      name: z8.string().min(1),
-      kind: z8.enum(["file", "dir"]),
-      size: z8.number().int().nonnegative().nullable()
+    entries: z9.array(z9.object({
+      name: z9.string().min(1),
+      kind: z9.enum(["file", "dir"]),
+      size: z9.number().int().nonnegative().nullable()
     }))
   })
 ]);
-var BranchChangesReadSchema = z8.object({
+var BranchChangesReadSchema = z9.object({
   repo: ProjectRepoSchema,
   branch: BranchNameSchema
 });
-var BranchFileChangeSchema = z8.object({
-  path: z8.string().min(1),
-  status: z8.enum(["added", "modified", "deleted"]),
+var BranchFileChangeSchema = z9.object({
+  path: z9.string().min(1),
+  status: z9.enum(["added", "modified", "deleted"]),
   /** Lines added and removed, or null for a binary file. */
-  added: z8.number().int().nonnegative().nullable(),
-  removed: z8.number().int().nonnegative().nullable(),
+  added: z9.number().int().nonnegative().nullable(),
+  removed: z9.number().int().nonnegative().nullable(),
   /** Absent when the file changed only through a merge of another branch. */
-  lastChange: z8.object({ author: z8.string(), at: IsoDateTimeSchema }).optional()
+  lastChange: z9.object({ author: z9.string(), at: IsoDateTimeSchema }).optional()
 });
-var BranchChangesSchema = z8.object({
+var BranchChangesSchema = z9.object({
   head: BranchCommitSchema,
-  files: z8.array(BranchFileChangeSchema),
-  total: z8.number().int().nonnegative()
+  files: z9.array(BranchFileChangeSchema),
+  total: z9.number().int().nonnegative()
 });
-var BranchDiffReadSchema = z8.object({
+var BranchDiffReadSchema = z9.object({
   repo: ProjectRepoSchema,
   branch: BranchNameSchema,
   path: BranchPathSchema.min(1)
 });
-var BranchFileDiffSchema = z8.object({
+var BranchFileDiffSchema = z9.object({
   head: BranchCommitSchema,
   path: BranchPathSchema,
   status: BranchFileChangeSchema.shape.status,
-  patch: z8.string().nullable(),
-  truncated: z8.boolean()
+  patch: z9.string().nullable(),
+  truncated: z9.boolean()
 });
 function patchHunks(patch, limit) {
   if (/^Binary files .* differ$/m.test(patch)) {
@@ -1548,69 +1634,89 @@ function patchHunks(patch, limit) {
   const cut = hunks.lastIndexOf("\n", limit);
   return { patch: hunks.slice(0, cut === -1 ? limit : cut), truncated: true };
 }
-var WorkspaceConversationSchema = z8.discriminatedUnion("kind", [
-  z8.object({ kind: z8.literal("thread"), id: UlidSchema }),
-  z8.object({ kind: z8.literal("channel"), scope: NameSchema, name: NameSchema })
+var TurnImageReadSchema = z9.object({
+  turnId: UlidSchema,
+  path: ImagePathSchema
+});
+var ImageRefusalSchema = z9.enum(["missing", "outside", "not_image", "too_big"]);
+var TurnImageSchema = z9.discriminatedUnion("kind", [
+  z9.object({
+    kind: z9.literal("image"),
+    type: ImageTypeSchema,
+    size: z9.number().int().positive(),
+    content: z9.string()
+  }),
+  z9.object({ kind: z9.literal("refused"), why: ImageRefusalSchema, detail: z9.string() })
 ]);
-var HeldWorkspaceSchema = z8.object({
+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("place"), project: NameSchema })
+]);
+var HeldWorkspaceSchema = z9.object({
   agent: NameSchema,
   scope: NameSchema,
   conversation: WorkspaceConversationSchema
 });
-var HeldWorkspacesSchema = z8.object({ workspaces: z8.array(HeldWorkspaceSchema) });
-var SweepResultSchema = z8.object({ kept: z8.array(HeldWorkspaceSchema) });
-var TurnSteerSchema = z8.object({ id: z8.uuid(), text: z8.string().min(1) });
-var RunnerMessageSchema = z8.discriminatedUnion("type", [
-  z8.object({ type: z8.literal("turn"), job: TurnJobSchema }),
-  z8.object({ type: z8.literal("land"), request: z8.string().min(1), land: LandRequestSchema }),
+var HeldWorkspacesSchema = z9.object({ workspaces: z9.array(HeldWorkspaceSchema) });
+var SweepResultSchema = z9.object({ kept: z9.array(HeldWorkspaceSchema) });
+var TurnSteerSchema = z9.object({ id: z9.uuid(), text: z9.string().min(1) });
+var RunnerMessageSchema = z9.discriminatedUnion("type", [
+  z9.object({ type: z9.literal("turn"), job: TurnJobSchema }),
+  z9.object({ type: z9.literal("land"), request: z9.string().min(1), land: LandRequestSchema }),
   /** Answered with a `MergeOutcome`. */
-  z8.object({ type: z8.literal("close"), request: z8.string().min(1), close: CloseRequestSchema }),
-  z8.object({ type: z8.literal("models"), request: z8.string().min(1), cli: CliKindSchema }),
+  z9.object({ type: z9.literal("close"), request: z9.string().min(1), close: CloseRequestSchema }),
+  z9.object({ type: z9.literal("models"), request: z9.string().min(1), cli: CliKindSchema }),
   /**
    * Answered with a `CliQuota` read from the CLI without a turn, or null when its adapter cannot
    * read one. Sent only to runners whose hello says `quotaReads`.
    */
-  z8.object({ type: z8.literal("quota"), request: z8.string().min(1), cli: CliKindSchema }),
+  z9.object({ type: z9.literal("quota"), request: z9.string().min(1), cli: CliKindSchema }),
   /** Answered with a `BranchFile`, or null when the branch or the path does not exist. */
-  z8.object({ type: z8.literal("file"), request: z8.string().min(1), read: BranchReadSchema }),
+  z9.object({ type: z9.literal("file"), request: z9.string().min(1), read: BranchReadSchema }),
   /** Answered with `BranchChanges`, or null when the repository or the branch does not exist. */
-  z8.object({
-    type: z8.literal("changes"),
-    request: z8.string().min(1),
+  z9.object({
+    type: z9.literal("changes"),
+    request: z9.string().min(1),
     read: BranchChangesReadSchema
   }),
   /** Answered with a `BranchFileDiff`, or null when the branch does not exist or left the path alone. */
-  z8.object({ type: z8.literal("diff"), request: z8.string().min(1), read: BranchDiffReadSchema }),
+  z9.object({ type: z9.literal("diff"), request: z9.string().min(1), read: BranchDiffReadSchema }),
+  /**
+   * Answered with a `TurnImage`, or null when the turn is not running there. Sent only to runners
+   * whose hello says `imageReads`.
+   */
+  z9.object({ type: z9.literal("image"), request: z9.string().min(1), read: TurnImageReadSchema }),
   /** Answered with whether the CLI accepted it; that it took it comes as a `steered` event. */
-  z8.object({
-    type: z8.literal("steer"),
-    request: z8.string().min(1),
+  z9.object({
+    type: z9.literal("steer"),
+    request: z9.string().min(1),
     turnId: UlidSchema,
     steer: TurnSteerSchema
   }),
   /** Answered with whether the turn was there to stop; it ends `stopped`. */
-  z8.object({ type: z8.literal("stop"), request: z8.string().min(1), turnId: UlidSchema }),
+  z9.object({ type: z9.literal("stop"), request: z9.string().min(1), turnId: UlidSchema }),
   /**
    * A conversation ended: the runner removes every citizen's workspace for it but those a turn
    * still uses, and answers with a `SweepResult` naming those it kept for holding work on no branch.
    */
-  z8.object({
-    type: z8.literal("sweep"),
-    request: z8.string().min(1),
+  z9.object({
+    type: z9.literal("sweep"),
+    request: z9.string().min(1),
     conversation: WorkspaceConversationSchema
   })
 ]);
-var RunnerAnswerSchema = z8.discriminatedUnion("ok", [
-  z8.object({ ok: z8.literal(true), value: z8.unknown() }),
-  z8.object({ ok: z8.literal(false), error: z8.string() })
+var RunnerAnswerSchema = z9.discriminatedUnion("ok", [
+  z9.object({ ok: z9.literal(true), value: z9.unknown() }),
+  z9.object({ ok: z9.literal(false), error: z9.string() })
 ]);
-var WarmSessionsSchema = z8.object({ warm: z8.array(z8.string()) });
-var FileManifestSchema = z8.object({ files: z8.record(z8.string(), z8.string()) });
+var WarmSessionsSchema = z9.object({ warm: z9.array(z9.string()) });
+var FileManifestSchema = z9.object({ files: z9.record(z9.string(), z9.string()) });
 function fileVersion(sha, executable) {
   return executable ? `${sha}+x` : sha;
 }
-var FileReadSchema = z8.object({ paths: z8.array(z8.string()) });
-var FileContentsSchema = z8.object({ files: z8.record(z8.string(), z8.string()) });
+var FileReadSchema = z9.object({ paths: z9.array(z9.string()) });
+var FileContentsSchema = z9.object({ files: z9.record(z9.string(), z9.string()) });
 function isSafeRelativePath(file) {
   if (file.length === 0 || file.startsWith("/") || file.includes("\\") || file.includes("\0")) {
     return false;
@@ -1619,7 +1725,7 @@ function isSafeRelativePath(file) {
 }
 
 // packages/shared/dist/turns.js
-var TriggerKindSchema = z9.enum([
+var TriggerKindSchema = z10.enum([
   "mention",
   "stage",
   "task_done",
@@ -1633,11 +1739,11 @@ var TriggerKindSchema = z9.enum([
   "closing",
   "cron"
 ]);
-var TriggerSchema = z9.object({
+var TriggerSchema = z10.object({
   kind: TriggerKindSchema,
   from: NameSchema.optional(),
-  fromUser: z9.boolean().default(false),
-  reason: z9.string().default(""),
+  fromUser: z10.boolean().default(false),
+  reason: z10.string().default(""),
   taskId: UlidSchema.optional(),
   messageId: UlidSchema.optional(),
   /** The channel the waking message was posted in. */
@@ -1645,20 +1751,27 @@ var TriggerSchema = z9.object({
   /** The cron that came due, for a `cron` wake. */
   cronId: UlidSchema.optional()
 });
-var TurnThreadSchema = z9.object({ id: UlidSchema, task: z9.boolean() });
-var TurnDispatchSchema = z9.object({
+var TurnThreadSchema = z10.object({ id: UlidSchema, task: z10.boolean() });
+var TurnDispatchSchema = z10.object({
   agent: NameSchema,
   project: NameSchema,
   thread: TurnThreadSchema.optional(),
   channel: NameSchema.optional(),
+  place: NameSchema.optional(),
   trigger: TriggerSchema,
-  priority: z9.number().int().min(0).max(2),
-  onboarding: z9.boolean().default(false),
+  priority: z10.number().int().min(0).max(2),
+  onboarding: z10.boolean().default(false),
   /** Every cron that came due for this turn, whatever wake it merged into; its prompt quotes each. */
-  crons: z9.array(UlidSchema).optional()
+  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("/");
@@ -1666,7 +1779,11 @@ function channelConversation(scope, channel) {
   const name = at < 0 ? channel : channel.slice(at + 1);
   return place === scope && name !== "general" ? name : void 0;
 }
-var TurnRecordSchema = z9.object({
+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(),
   agent: NameSchema,
@@ -1675,83 +1792,94 @@ var TurnRecordSchema = z9.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: z9.string().nullable(),
+  session: z10.string().nullable(),
   trigger: TriggerSchema,
   startedAt: IsoDateTimeSchema,
   endedAt: IsoDateTimeSchema.nullable(),
   exitReason: TurnExitReasonSchema.nullable(),
   status: TurnStatusSchema.nullable(),
-  error: z9.string().nullable(),
+  error: z10.string().nullable(),
   usage: UsageSchema.nullable(),
-  costUsd: z9.number().nonnegative().default(0),
+  costUsd: z10.number().nonnegative().default(0),
   /**
    * The running total the CLI reported for the session after this turn, when it reports one. A
    * resumed session starts from it, so the next turn's own cost is measured from here.
    */
-  sessionCostUsd: z9.number().nonnegative().optional(),
-  toolCalls: z9.number().int().nonnegative().default(0),
+  sessionCostUsd: z10.number().nonnegative().optional(),
+  toolCalls: z10.number().int().nonnegative().default(0),
   /** The model the CLI reported for this turn, else the model configured for the agent, else null. */
-  model: z9.string().nullable().default(null),
+  model: z10.string().nullable().default(null),
   /** The task branch the turn left work on, with its commit, as the runner reported it. */
   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(),
+  /** 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: z9.array(UlidSchema).optional()
+  crons: z10.array(UlidSchema).optional()
 });
-var RunningTurnSchema = z9.object({
+var RunningTurnSchema = z10.object({
   turnId: UlidSchema,
   agent: NameSchema,
   scope: NameSchema,
   thread: UlidSchema.optional(),
   channel: NameSchema.optional(),
+  place: NameSchema.optional(),
   cli: CliKindSchema,
   askedIn: ChannelRefSchema.optional(),
-  steerable: z9.boolean(),
-  stoppable: z9.boolean()
+  steerable: z10.boolean(),
+  stoppable: z10.boolean()
 });
-var SessionsFileSchema = z9.object({
-  claude: z9.string().optional(),
-  codex: z9.string().optional(),
+var SessionsFileSchema = z10.object({
+  claude: z10.string().optional(),
+  codex: z10.string().optional(),
   runner: NameSchema.optional()
 });
-var WakeRequestSchema = z9.object({
+var WakeRequestSchema = z10.object({
   agent: NameSchema,
   project: NameSchema,
-  reason: z9.string().default("manual wake"),
+  reason: z10.string().default("manual wake"),
   /** A manual wake, or a reflection turn requested ahead of the cadence. */
-  kind: z9.enum(["manual", "reflection"]).default("manual")
+  kind: z10.enum(["manual", "reflection"]).default("manual")
 });
-var TurnHistoryEntrySchema = z9.object({
+var TurnHistoryEntrySchema = z10.object({
   /** The id of the event that ended the turn. */
   id: UlidSchema,
   /** The turn's own id, when it has a transcript to open; turns before transcripts have none. */
   turnId: UlidSchema.optional(),
   ts: IsoDateTimeSchema,
-  outcome: z9.enum(["completed", "failed"]),
+  outcome: z10.enum(["completed", "failed"]),
   /** A project slug, or the society scope. */
   project: NameSchema,
   /** The thread whose conversation the turn was in; absent for the home conversation. */
   thread: UlidSchema.optional(),
   /** The channel, never general, whose conversation the turn was in. */
   channel: NameSchema.optional(),
-  trigger: z9.string(),
-  exitReason: z9.string().nullable(),
-  costUsd: z9.number(),
+  /** 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(),
   /** The tokens the turn used; absent for turns logged before turns recorded them. */
   usage: UsageSchema.optional(),
-  model: z9.string().nullable(),
-  summary: z9.string().nullable(),
-  error: z9.string().nullable(),
+  model: z10.string().nullable(),
+  summary: z10.string().nullable(),
+  error: z10.string().nullable(),
   /** When the log recorded the turn's start; absent when the start is missing from the log. */
   startedAt: IsoDateTimeSchema.optional(),
-  toolCalls: z9.number().int().nonnegative().optional()
+  toolCalls: z10.number().int().nonnegative().optional()
 });
 
 // packages/shared/dist/ops.js
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var OPS_SIGNAL_KINDS = [
   "waiting_stage",
   "backlog",
@@ -1767,16 +1895,16 @@ var OPS_SIGNAL_KINDS = [
   "stuck_workspace",
   "cron_failing"
 ];
-var OpsSignalKindSchema = z10.enum(OPS_SIGNAL_KINDS);
-var OpsSignalSchema = z10.object({
+var OpsSignalKindSchema = z11.enum(OPS_SIGNAL_KINDS);
+var OpsSignalSchema = z11.object({
   kind: OpsSignalKindSchema,
   /** Identifies the condition, for example `backlog:demo:engineer`, so a persisting one is not logged again every pass. */
-  key: z10.string().min(1),
+  key: z11.string().min(1),
   /** One line a reader can act on. */
-  summary: z10.string().min(1),
+  summary: z11.string().min(1),
   /** The counter or timer value behind the signal. */
-  value: z10.number(),
-  threshold: z10.number().optional(),
+  value: z11.number(),
+  threshold: z11.number().optional(),
   project: NameSchema.optional(),
   agent: NameSchema.optional(),
   role: NameSchema.optional(),
@@ -1784,8 +1912,8 @@ var OpsSignalSchema = z10.object({
 });
 
 // packages/shared/dist/metrics.js
-import { z as z11 } from "zod";
-var MetricsWindowSchema = z11.enum(["24h", "7d", "all"]);
+import { z as z12 } from "zod";
+var MetricsWindowSchema = z12.enum(["24h", "7d", "all"]);
 var METRICS_WINDOW_MS = {
   "24h": 24 * 36e5,
   "7d": 7 * 24 * 36e5,
@@ -1796,9 +1924,9 @@ function isBoardAction(tool) {
   const verb = /^mcp__board__(.+)$/.exec(tool)?.[1];
   return verb !== void 0 && !READ_VERBS.some((read2) => read2 === verb);
 }
-var CountSchema = z11.number().int().nonnegative();
-var MsSchema = z11.number().nonnegative();
-var MetricsSchema = z11.object({
+var CountSchema = z12.number().int().nonnegative();
+var MsSchema = z12.number().nonnegative();
+var MetricsSchema = z12.object({
   window: MetricsWindowSchema,
   since: IsoDateTimeSchema.nullable(),
   until: IsoDateTimeSchema,
@@ -1806,12 +1934,12 @@ var MetricsSchema = z11.object({
    * Finished turns that changed nothing on the board. Reflections are left out, since they write
    * memory, not the board; turns without a transcript are counted apart, their actions unknown.
    */
-  idle: z11.object({
+  idle: z12.object({
     turns: CountSchema,
     idle: CountSchema,
     unknown: CountSchema,
-    byTrigger: z11.array(z11.object({ trigger: z11.string(), turns: CountSchema, idle: CountSchema })),
-    byAgent: z11.array(z11.object({
+    byTrigger: z12.array(z12.object({ trigger: z12.string(), turns: CountSchema, idle: CountSchema })),
+    byAgent: z12.array(z12.object({
       agent: NameSchema,
       role: NameSchema.nullable(),
       turns: CountSchema,
@@ -1819,33 +1947,33 @@ var MetricsSchema = z11.object({
     }))
   }),
   /** Work sent back to an earlier stage: over the tasks finished in the window, and by where. */
-  sentBack: z11.object({
+  sentBack: z12.object({
     finished: CountSchema,
     sendBacks: CountSchema,
     tasksSentBack: CountSchema,
-    byStage: z11.array(z11.object({ project: NameSchema, stage: z11.string(), count: CountSchema })),
-    bySender: z11.array(z11.object({ agent: NameSchema, count: CountSchema }))
+    byStage: z12.array(z12.object({ project: NameSchema, stage: z12.string(), count: CountSchema })),
+    bySender: z12.array(z12.object({ agent: NameSchema, count: CountSchema }))
   }),
   /** Posts in the threads of the tasks finished in the window, the board's own notices left out. */
-  messages: z11.object({
+  messages: z12.object({
     finished: CountSchema,
     messages: CountSchema,
-    byProject: z11.array(z11.object({ project: NameSchema, finished: CountSchema, messages: CountSchema })),
-    busiest: z11.array(z11.object({
+    byProject: z12.array(z12.object({ project: NameSchema, finished: CountSchema, messages: CountSchema })),
+    busiest: z12.array(z12.object({
       taskId: UlidSchema,
-      title: z11.string(),
+      title: z12.string(),
       project: NameSchema,
       messages: CountSchema
     }))
   }),
   /** Time from a mention to the start of the turn it woke, in the conversation it was made in. */
-  latency: z11.object({
+  latency: z12.object({
     mentions: CountSchema,
     /** Mentions no turn has followed yet. */
     unanswered: CountSchema,
     medianMs: MsSchema.nullable(),
     slowestMs: MsSchema.nullable(),
-    byAgent: z11.array(z11.object({
+    byAgent: z12.array(z12.object({
       agent: NameSchema,
       mentions: CountSchema,
       medianMs: MsSchema,
@@ -1853,93 +1981,93 @@ var MetricsSchema = z11.object({
     }))
   }),
   /** The user's decisions: proposals decided, questions answered, and stages passed or sent back. */
-  decisions: z11.object({
+  decisions: z12.object({
     total: CountSchema,
-    byDay: z11.array(z11.object({
-      day: z11.string(),
+    byDay: z12.array(z12.object({
+      day: z12.string(),
       proposals: CountSchema,
       answers: CountSchema,
       stages: CountSchema
     }))
   }),
   /** Tasks that needed a capability no connected runner offered, and whether they still do. */
-  blocked: z11.array(z11.object({
+  blocked: z12.array(z12.object({
     taskId: UlidSchema,
-    title: z11.string().nullable(),
+    title: z12.string().nullable(),
     project: NameSchema.nullable(),
-    summary: z11.string(),
+    summary: z12.string(),
     firstAt: IsoDateTimeSchema,
     lastAt: IsoDateTimeSchema,
-    holds: z11.boolean()
+    holds: z12.boolean()
   }))
 });
-var CitizenTokensSchema = z11.object({
+var CitizenTokensSchema = z12.object({
   agent: NameSchema,
   turns: CountSchema,
   withUsage: CountSchema,
   usage: UsageSchema.nullable()
 });
-var TokenUseSchema = z11.object({
+var TokenUseSchema = z12.object({
   window: MetricsWindowSchema,
   since: IsoDateTimeSchema.nullable(),
   until: IsoDateTimeSchema,
-  citizens: z11.array(CitizenTokensSchema)
+  citizens: z12.array(CitizenTokensSchema)
 });
 
 // packages/shared/dist/config.js
-import { z as z12 } from "zod";
-var LogLevelSchema = z12.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
-var GithubSignInSchema = z12.object({
-  clientId: z12.string().min(1),
-  clientSecret: z12.string().min(1),
+import { z as z13 } from "zod";
+var LogLevelSchema = z13.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
+var GithubSignInSchema = z13.object({
+  clientId: z13.string().min(1),
+  clientSecret: z13.string().min(1),
   /** Logins, lowercased; GitHub logins are case-insensitive. */
-  users: z12.array(z12.string().min(1)).min(1)
+  users: z13.array(z13.string().min(1)).min(1)
 });
-var ServerConfigSchema = z12.object({
-  dataDir: z12.string().min(1),
-  host: z12.string().min(1),
-  port: z12.number().int().positive().max(65535),
+var ServerConfigSchema = z13.object({
+  dataDir: z13.string().min(1),
+  host: z13.string().min(1),
+  port: z13.number().int().positive().max(65535),
   /**
    * An address every runner's agents reach this server at, for example https://board.example, or
    * null for each runner to use the address it reaches the server at itself.
    */
-  publicUrl: z12.string().min(1).nullable(),
+  publicUrl: z13.string().min(1).nullable(),
   logLevel: LogLevelSchema,
   /** Turns running at once across every runner, or null for no limit beyond each runner's own. */
-  concurrency: z12.number().int().positive().nullable(),
+  concurrency: z13.number().int().positive().nullable(),
   /** How long one turn may run before it is stopped, or null for no limit. */
-  turnTimeoutMs: z12.number().int().positive().nullable(),
+  turnTimeoutMs: z13.number().int().positive().nullable(),
   /** Rounds of tool calls one Claude turn may take, or null for no limit. */
-  toolRounds: z12.number().int().positive().nullable(),
+  toolRounds: z13.number().int().positive().nullable(),
   /** How long a resident session stays warm after its last turn. */
-  residentIdleMs: z12.number().int().positive(),
+  residentIdleMs: z13.number().int().positive(),
   /** Signing in to the board with GitHub, or null when only a token lets anyone in. */
   github: GithubSignInSchema.nullable(),
   /**
    * Reverse proxies in front of the server whose X-Forwarded-For entries name the client, for the
    * rate limits on what anyone may ask without a token: 0 when clients connect directly.
    */
-  trustedProxies: z12.number().int().min(0).max(16)
+  trustedProxies: z13.number().int().min(0).max(16)
 });
-var RunnerConfigSchema = z12.object({
+var RunnerConfigSchema = z13.object({
   /** The board server, for example http://127.0.0.1:4700. */
-  serverUrl: z12.string().url(),
+  serverUrl: z13.string().url(),
   /**
    * The runner's token, from `runner add`, or null for the one it saved when it was enrolled, or
    * to enroll it.
    */
-  token: z12.string().min(1).nullable(),
+  token: z13.string().min(1).nullable(),
   /** The runner's own data directory: the board mirror, agent homes, repositories, worktrees. */
-  dataDir: z12.string().min(1),
+  dataDir: z13.string().min(1),
   logLevel: LogLevelSchema,
   /** Turns this machine runs at once, or null for no limit. */
-  slots: z12.number().int().positive().nullable(),
-  clis: z12.array(CliKindSchema).min(1),
-  capabilities: z12.array(z12.string())
+  slots: z13.number().int().positive().nullable(),
+  clis: z13.array(CliKindSchema).min(1),
+  capabilities: z13.array(z13.string())
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.3.22";
+var STELLARIS_VERSION = "0.3.24";
 
 // packages/shared/dist/mentions.js
 import { parse, postprocess, preprocess } from "micromark";
@@ -2320,6 +2448,7 @@ var HOME_GITIGNORE = [
   "/projects/*/last-turn.json",
   "/projects/*/threads/",
   "/projects/*/channels/",
+  "/projects/*/places/",
   `/${HOME_SCRATCH}/`,
   "*.tmp",
   "node_modules/",
@@ -2337,7 +2466,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
@@ -2657,32 +2786,33 @@ function postMentions(body) {
 }
 
 // packages/board-core/dist/metrics.js
-import { z as z13 } from "zod";
-var TurnPayload = z13.object({
-  turnId: z13.string().optional(),
-  project: z13.string(),
-  thread: z13.string().optional(),
-  channel: z13.string().optional(),
-  trigger: z13.string()
-});
-var TaskPayload = z13.object({
-  taskId: z13.string(),
-  project: z13.string(),
-  from: z13.string().optional()
-});
-var MessagePayload = z13.object({
-  id: z13.string().optional(),
-  channel: z13.string(),
-  thread: z13.string().nullable().optional(),
-  mentions: z13.array(z13.string()).default([])
-});
-var SteeredPayload = z13.object({ messages: z13.array(z13.string()) });
-var SignalPayload = z13.object({
-  kind: z13.string(),
-  key: z13.string(),
-  summary: z13.string(),
-  taskId: z13.string().optional(),
-  project: z13.string().optional()
+import { z as z14 } from "zod";
+var TurnPayload = z14.object({
+  turnId: z14.string().optional(),
+  project: z14.string(),
+  thread: z14.string().optional(),
+  channel: z14.string().optional(),
+  place: z14.string().optional(),
+  trigger: z14.string()
+});
+var TaskPayload = z14.object({
+  taskId: z14.string(),
+  project: z14.string(),
+  from: z14.string().optional()
+});
+var MessagePayload = z14.object({
+  id: z14.string().optional(),
+  channel: z14.string(),
+  thread: z14.string().nullable().optional(),
+  mentions: z14.array(z14.string()).default([])
+});
+var SteeredPayload = z14.object({ messages: z14.array(z14.string()) });
+var SignalPayload = z14.object({
+  kind: z14.string(),
+  key: z14.string(),
+  summary: z14.string(),
+  taskId: z14.string().optional(),
+  project: z14.string().optional()
 });
 function median(values) {
   const sorted = values.toSorted((a, b) => a - b);
@@ -2708,11 +2838,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;
   }
-  return mention.thread === null && own === void 0 || turn2.trigger === "mention";
+  if (turn2.place !== null) {
+    return topLevel && place === turn2.place;
+  }
+  return topLevel && own === void 0 && place === void 0 || turn2.trigger === "mention";
 }
 function computeMetrics(input) {
   const { events, now, window } = input;
@@ -2778,6 +2913,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
         };
@@ -2972,19 +3108,20 @@ function computeMetrics(input) {
 }
 
 // packages/board-core/dist/turn-history.js
-import { z as z14 } from "zod";
-var TurnHistoryPayloadSchema = z14.object({
+import { z as z15 } from "zod";
+var TurnHistoryPayloadSchema = z15.object({
   project: NameSchema,
   thread: UlidSchema.optional(),
   channel: NameSchema.optional(),
-  trigger: z14.string().default("manual"),
-  exitReason: z14.string().nullable().default(null),
-  costUsd: z14.number().default(0),
+  place: NameSchema.optional(),
+  trigger: z15.string().default("manual"),
+  exitReason: z15.string().nullable().default(null),
+  costUsd: z15.number().default(0),
   usage: UsageSchema.optional(),
-  model: z14.string().nullable().default(null),
-  summary: z14.string().nullable().default(null),
-  error: z14.string().nullable().default(null),
-  toolCalls: z14.number().int().nonnegative().optional(),
+  model: z15.string().nullable().default(null),
+  summary: z15.string().nullable().default(null),
+  error: z15.string().nullable().default(null),
+  toolCalls: z15.number().int().nonnegative().optional(),
   turnId: UlidSchema.optional()
 });
 function tokenUse(events, window, now) {
@@ -3215,11 +3352,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");
@@ -3230,6 +3370,13 @@ var BoardPaths = class {
   eventLog() {
     return path5.join(this.events(), "log.jsonl");
   }
+  /** Images citizens uploaded, by id: outside the projection, which every runner mirrors. */
+  images() {
+    return path5.join(this.dataDir, "images");
+  }
+  image(id) {
+    return path5.join(this.images(), id);
+  }
   state() {
     return path5.join(this.dataDir, "state");
   }
@@ -3246,6 +3393,101 @@ var BoardPaths = class {
   }
 };
 
+// packages/board-core/dist/skill-folder.js
+import { constants } from "node:fs";
+import { lstat, open as open2, readdir as readdir3, realpath } from "node:fs/promises";
+import 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 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 {
+    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() {
@@ -3259,48 +3501,62 @@ 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) ?? ""}`;
 }
 var SKIPPED_IN_HOME = /* @__PURE__ */ new Set([".git", "turns", ".claude", ".codex"]);
-var RunnerTokensSchema = z15.object({
-  runners: z15.record(z15.string(), z15.object({ tokenHash: z15.string().min(1) }))
+var RunnerTokensSchema = z16.object({
+  runners: z16.record(z16.string(), z16.object({ tokenHash: z16.string().min(1) }))
 });
-var SignInsSchema = z15.object({
-  signIns: z15.array(z15.object({
-    tokenHash: z15.string().min(1),
-    login: z15.string().min(1),
+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. */
-    avatarUrl: z15.url().optional(),
+    avatarUrl: z16.url().optional(),
     createdAt: IsoDateTimeSchema,
     expiresAt: IsoDateTimeSchema
   })).default([])
 });
-var TurnStartPayloadSchema = z15.object({ project: NameSchema, turnId: UlidSchema.optional() });
-var CursorsSchema = z15.object({
-  digest: z15.string().nullable(),
-  scopes: z15.record(z15.string(), z15.string()).default({}),
-  threadsFrom: z15.record(z15.string(), z15.string().nullable()).default({}),
-  channelsFrom: z15.record(z15.string(), z15.string().nullable()).default({}),
+var TurnStartPayloadSchema = z16.object({ project: NameSchema, turnId: UlidSchema.optional() });
+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: z15.string().optional()
-});
-var NO_CURSORS = { digest: null, scopes: {}, threadsFrom: {}, channelsFrom: {} };
+  news: z16.string().optional()
+});
+var NO_CURSORS = {
+  digest: null,
+  scopes: {},
+  threadsFrom: {},
+  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 placeStart(cursors, scope) {
+  const from = cursors.placesFrom[scope];
+  return from === void 0 ? cursors.digest : from;
+}
 function threadStart(cursors, scope) {
   const from = cursors.threadsFrom[scope];
   return from === void 0 ? cursors.digest : from;
@@ -3316,7 +3572,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) : threadStart(cursors, scope));
 }
 function byId(a, b) {
   return a.message.id < b.message.id ? -1 : a.message.id > b.message.id ? 1 : 0;
@@ -3324,12 +3580,14 @@ function byId(a, b) {
 function turnTime(record) {
   return record.endedAt ?? record.startedAt;
 }
-var PausedSchema = z15.object({ paused: z15.boolean() });
+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;
@@ -3338,7 +3596,7 @@ function skillFolderOf(proposal2) {
   return parsed.success && parsed.data.body === void 0 ? parsed.data.name : null;
 }
 function proposedFrom(origin, where) {
-  return origin !== void 0 && origin.scope === where.scope && origin.thread === where.thread && origin.channel === where.channel;
+  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$/, "");
@@ -3349,7 +3607,7 @@ var OPS_WAKE_TRIGGER = "ops_event";
 var FRONT_DESK_TRIGGER = "user_post";
 var OPS_CHANNELS = ["governance"];
 var FRONT_DESK_CHANNELS = [ASK_CHANNEL];
-var AlignmentsSchema = z15.object({ applied: z15.array(z15.string()).default([]) });
+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";
@@ -3360,13 +3618,15 @@ var THREAD_CONVERSATIONS = "thread-conversations";
 var ASKS_CHANNEL_OPENED = "asks-channel-opened";
 var KNOWLEDGE_REMOVAL = "knowledge-removal-granted";
 var CHANNEL_CONVERSATIONS = "channel-conversations";
+var PLACE_CONVERSATIONS = "place-conversations";
 var DASHBOARD_UPDATES = "dashboard-updates-granted";
 var CRON_VERBS = "cron-verbs-granted";
 var KNOWLEDGE_NOTICES = "knowledge-notices";
-var KnowledgeEventSchema = z15.object({
+var IMAGE_UPLOADS = "image-uploads-granted";
+var KnowledgeEventSchema = z16.object({
   topic: NameSchema,
   project: NameSchema.nullable(),
-  replaced: z15.boolean().optional()
+  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.";
@@ -3433,8 +3693,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 = [];
@@ -3498,6 +3758,7 @@ var Board = class _Board {
   mutex = new Mutex();
   /** The turns in flight, which the server hosting them supplies; none until it does. */
   turnsInFlight = () => [];
+  imageSource = null;
   newId = monotonicFactory();
   events;
   actionCounts = /* @__PURE__ */ new Map();
@@ -3514,7 +3775,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);
@@ -3547,7 +3808,7 @@ var Board = class _Board {
    * repeated, so a member that later chooses otherwise keeps its choice.
    */
   async applyAlignments() {
-    const file = path6.join(this.paths.state(), "alignments.json");
+    const file = path7.join(this.paths.state(), "alignments.json");
     const { applied } = await exists(file) ? await readJson(file, AlignmentsSchema) : { applied: [] };
     const pending = [
       FOLLOW_DECISIONS,
@@ -3562,7 +3823,9 @@ var Board = class _Board {
       CHANNEL_CONVERSATIONS,
       DASHBOARD_UPDATES,
       CRON_VERBS,
-      KNOWLEDGE_NOTICES
+      KNOWLEDGE_NOTICES,
+      IMAGE_UPLOADS,
+      PLACE_CONVERSATIONS
     ].filter((name) => !applied.includes(name));
     if (pending.length === 0) {
       return;
@@ -3592,13 +3855,13 @@ var Board = class _Board {
       await this.openAsksChannel();
     }
     if (pending.includes(KNOWLEDGE_REMOVAL)) {
-      await this.grantBesideKnowledge("remove_knowledge");
+      await this.grantBeside("write_knowledge", "remove_knowledge");
     }
     if (pending.includes(CHANNEL_CONVERSATIONS)) {
       await this.startChannelCursors();
     }
     if (pending.includes(DASHBOARD_UPDATES)) {
-      await this.grantBesideKnowledge("update_dashboard");
+      await this.grantBeside("write_knowledge", "update_dashboard");
       await this.rewordDashboards();
     }
     if (pending.includes(CRON_VERBS)) {
@@ -3607,6 +3870,12 @@ var Board = class _Board {
     if (pending.includes(KNOWLEDGE_NOTICES)) {
       await this.noticeKnowledgeNotes();
     }
+    if (pending.includes(IMAGE_UPLOADS)) {
+      await this.grantBeside("post_message", "upload_image");
+    }
+    if (pending.includes(PLACE_CONVERSATIONS)) {
+      await this.startPlaceCursors();
+    }
     await writeJson(file, { applied: [...applied, ...pending] });
   }
   /**
@@ -3648,12 +3917,12 @@ var Board = class _Board {
     }
   }
   /**
-   * Grants `verb` once to every charter granting `write_knowledge`, the work roles' charters in
-   * practice; seed roles have it from their seed.
+   * Grants `verb` once to every charter granting `beside`, the work roles' charters in practice;
+   * seed roles have it from their seed.
    */
-  async grantBesideKnowledge(verb) {
+  async grantBeside(beside, verb) {
     for (const charter of await this.listRoles()) {
-      if (charter.verbs.includes("write_knowledge") && !charter.verbs.includes(verb)) {
+      if (charter.verbs.includes(beside) && !charter.verbs.includes(verb)) {
         await this.writeRoleUnlocked(USER_NAME, { ...charter, verbs: [...charter.verbs, verb] }, { verbsAdded: [verb] });
       }
     }
@@ -3811,7 +4080,7 @@ var Board = class _Board {
         }
       }
       for (const file of await listFiles(this.paths.tasks(slug))) {
-        const raw = await readMarkdown(path6.join(this.paths.tasks(slug), file), z15.record(z15.string(), z15.unknown()));
+        const raw = await readMarkdown(path7.join(this.paths.tasks(slug), file), z16.record(z16.string(), z16.unknown()));
         const legacy = raw.data["thread"];
         if (legacy === void 0) {
           continue;
@@ -3819,7 +4088,7 @@ var Board = class _Board {
         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 open4 = legacy === "open" && !ended;
           const openedBy = opened.get(task2.id);
           const closedBy = closed.get(task2.id);
           await this.writeThread(threads, {
@@ -3827,10 +4096,10 @@ var Board = class _Board {
             channel: channelRef(slug, "general"),
             title: task2.title,
             subject: { kind: "task", id: task2.id },
-            state: open3 ? "open" : "closed",
+            state: open4 ? "open" : "closed",
             openedBy: openedBy?.actor ?? task2.createdBy,
             openedAt: openedBy?.ts ?? task2.createdAt,
-            ...open3 ? {} : {
+            ...open4 ? {} : {
               closedBy: closedBy?.actor ?? SYSTEM_ACTOR.name,
               closedAt: closedBy?.ts ?? this.now().toISOString()
             },
@@ -3862,6 +4131,24 @@ var Board = class _Board {
       await writeJson(file, { ...cursors, channelsFrom });
     }
   }
+  /**
+   * A project's channels were once read, from the society scope, in the society's home
+   * conversation, so a member had read each up to that cursor. Each project's conversation in the
+   * society scope starts from it now, as each takes a conversation of its own.
+   */
+  async startPlaceCursors() {
+    for (const agent2 of await this.listAgents()) {
+      const file = this.paths.agentCursors(agent2.name);
+      if (!await exists(file)) {
+        continue;
+      }
+      const cursors = await readJson(file, CursorsSchema);
+      await writeJson(file, {
+        ...cursors,
+        placesFrom: { [SOCIETY_SCOPE]: cursorOf(cursors, SOCIETY_SCOPE) }
+      });
+    }
+  }
   /**
    * Threads were once read in the scope's single conversation, so a member had read every thread
    * up to its scope's cursor. Each scope's threads start from that cursor now, as each thread's
@@ -3889,7 +4176,7 @@ var Board = class _Board {
    * turns, so it follows nothing now.
    */
   async renameInboxCursors() {
-    const Legacy = z15.object({ inbox: z15.string().nullable() });
+    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)) {
@@ -3935,7 +4222,7 @@ ${charter.purpose}
    */
   async alignSeedRole(seed) {
     const file = this.paths.role(seed.name);
-    const raw = await readMarkdown(file, z15.record(z15.string(), z15.unknown()));
+    const raw = await readMarkdown(file, z16.record(z16.string(), z16.unknown()));
     const current = RoleCharterSchema.parse(raw.data);
     const verbsAdded = seed.verbs.filter((verb) => !current.verbs.includes(verb));
     const fieldsAligned = RoleCharterSchema.keyof().options.filter((key) => key === "verbs" || seed[key] === void 0 ? false : seed.name === USER_ROLE ? JSON.stringify(seed[key]) !== JSON.stringify(current[key]) : !(key in raw.data));
@@ -4002,13 +4289,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
     });
@@ -4097,7 +4386,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();
@@ -4194,7 +4483,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;
@@ -4213,7 +4502,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;
@@ -4240,7 +4529,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;
@@ -4252,14 +4541,14 @@ ${charter.purpose}
   /** The society's norms, the one knowledge topic every turn loads. Empty until the steward writes it. */
   async readSocietyNorms() {
     const file = this.paths.societyKnowledgeFile("norms");
-    return await exists(file) ? (await readMarkdown(file, z15.record(z15.string(), z15.unknown()))).body : "";
+    return await exists(file) ? (await readMarkdown(file, z16.record(z16.string(), z16.unknown()))).body : "";
   }
   /** Knowledge topics of a project, or of the society when the project is null. */
   async listKnowledge(project2) {
     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;
   }
@@ -4272,7 +4561,7 @@ ${charter.purpose}
    */
   async knowledgeAt(file, project2, topic) {
     const { data, body } = await readLooseMarkdown(file);
-    const revision = z15.number().int().min(0).safeParse(data["revision"]);
+    const revision = z16.number().int().min(0).safeParse(data["revision"]);
     const updatedBy = NameSchema.safeParse(data["updatedBy"]);
     const updatedAt = IsoDateTimeSchema.safeParse(data["updatedAt"]);
     return {
@@ -4289,7 +4578,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;
@@ -4305,7 +4594,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;
       }
@@ -4395,7 +4684,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) {
@@ -4427,7 +4716,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;
         }
@@ -4454,7 +4743,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({
@@ -4821,16 +5110,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) {
@@ -4840,11 +5133,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 });
@@ -4902,8 +5207,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) {
@@ -4923,11 +5229,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),
+        threadStart(cursors, each),
+        channelStart(cursors, each),
+        placeStart(cursors, each)
+      ] : [cursorOf(cursors, each, conversation.part)]),
       ...newsFrom === void 0 ? [] : [newsFrom]
     ];
     const known = starts.filter((start) => start !== null);
@@ -4937,7 +5249,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,
@@ -4948,12 +5260,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;
       }
@@ -5018,7 +5336,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",
@@ -5039,7 +5357,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()) {
@@ -5052,7 +5370,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) {
@@ -5142,7 +5460,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
@@ -5190,7 +5508,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
@@ -5235,11 +5553,65 @@ ${current.body}`);
       return updated;
     });
   }
+  /**
+   * Keeps an image a citizen's turn names by its path, read on the runner the turn runs on, which
+   * refuses a file outside the turn's worktree, the citizen's home, and the system temp folder.
+   * Only the bytes of a PNG, JPEG, GIF, or WebP of at most `IMAGE_LIMIT_BYTES` are kept, checked
+   * here again whatever the runner said, under a new id outside the projection, so no runner
+   * mirrors them and no prompt carries them: a post shows the image by its `image:` address.
+   */
+  async uploadImage(actor, input) {
+    const args = VerbInputs.upload_image.parse(input);
+    await this.authorize(actor, "upload_image");
+    if (actor.scope === void 0) {
+      throw new BoardError("INVALID_STATE", "upload_image reads the file on the machine a turn runs on, so only a turn can call it");
+    }
+    if (this.imageSource === null) {
+      throw new BoardError("NOT_FOUND", "this board has no runners to read an image from");
+    }
+    const bytes = await this.imageSource(actor, args.path);
+    const type = imageTypeOf(bytes);
+    if (type === null) {
+      throw new BoardError("VALIDATION", `${args.path} is not a PNG, JPEG, GIF, or WebP image by its first bytes`);
+    }
+    if (bytes.byteLength > IMAGE_LIMIT_BYTES) {
+      throw new BoardError("VALIDATION", `${args.path} is ${bytes.byteLength} bytes, over the ${IMAGE_LIMIT_BYTES} an image may be`);
+    }
+    return this.mutex.run(async () => {
+      const id = this.newId();
+      await writeFileAtomic(this.paths.image(id), bytes);
+      await this.events.append("image.uploaded", actor.name, {
+        id,
+        type,
+        size: bytes.byteLength
+      });
+      const name = path7.basename(args.path).replaceAll(/[[\]\\\r\n]/g, "");
+      return {
+        id,
+        type,
+        size: bytes.byteLength,
+        markdown: `![${name}](${IMAGE_SCHEME}${id})`
+      };
+    });
+  }
+  /** An uploaded image's bytes and kind, which its first bytes tell. */
+  async readImage(id) {
+    const file = this.paths.image(UlidSchema.parse(id));
+    if (!await exists(file)) {
+      throw new BoardError("NOT_FOUND", `image ${id} not found`);
+    }
+    const bytes = await readFile4(file);
+    const type = imageTypeOf(bytes);
+    if (type === null) {
+      throw new BoardError("NOT_FOUND", `image ${id} is not an image the board shows`);
+    }
+    return { type, bytes };
+  }
   /** Every cron, ended ones included, oldest first. */
   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;
   }
@@ -5361,11 +5733,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,
@@ -5441,7 +5818,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) {
@@ -5626,6 +6004,13 @@ ${current.body}`);
   watchTurns(source) {
     this.turnsInFlight = source;
   }
+  /**
+   * Where `upload_image` reads a file from: the runner the calling turn runs on, through the server
+   * that hosts the runners. Without one, as in the admin CLI, nothing can be uploaded.
+   */
+  readImagesWith(source) {
+    this.imageSource = source;
+  }
   /**
    * Refuses to end conversations while another citizen's turn is in one of them: `cut` picks the
    * turns that would lose theirs. The caller's own turn is exempt, since ending a conversation
@@ -5645,17 +6030,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);
@@ -6196,7 +6584,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
@@ -6455,6 +6844,8 @@ ${rationale}`}`);
         return this.updateCron(actor, VerbInputs.update_cron.parse(input));
       case "remove_cron":
         return this.removeCron(actor, VerbInputs.remove_cron.parse(input));
+      case "upload_image":
+        return this.uploadImage(actor, VerbInputs.upload_image.parse(input));
       default:
         throw new BoardError("VALIDATION", `unknown verb ${String(verb)}`);
     }
@@ -6501,7 +6892,7 @@ ${rationale}`}`);
   }
   async readAgentRoleBody(agent2) {
     const file = this.paths.agentRole(agent2);
-    return await exists(file) ? (await readMarkdown(file, z15.record(z15.string(), z15.unknown()))).body : "";
+    return await exists(file) ? (await readMarkdown(file, z16.record(z16.string(), z16.unknown()))).body : "";
   }
   /** The steps of one finished turn, as the runner handed them over when it ended. */
   /**
@@ -6606,19 +6997,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) : {};
   }
   /**
@@ -6629,15 +7021,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. */
@@ -6645,8 +7056,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);
@@ -6667,6 +7079,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
@@ -6696,7 +7109,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, {
@@ -6704,6 +7118,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,
@@ -6713,7 +7128,9 @@ ${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.sessionDropped === true ? { sessionDropped: true } : {}
       });
     });
   }
@@ -6750,6 +7167,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
@@ -6760,7 +7191,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;
@@ -6812,9 +7243,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));
@@ -6888,11 +7323,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) {
@@ -6909,7 +7344,7 @@ ${rationale}`}`);
       return { project: slug, revision: 0, body: "" };
     }
     const { data, body } = await readLooseMarkdown(file);
-    const revision = z15.number().int().min(0).safeParse(data["revision"]);
+    const revision = z16.number().int().min(0).safeParse(data["revision"]);
     const updatedBy = NameSchema.safeParse(data["updatedBy"]);
     const updatedAt = IsoDateTimeSchema.safeParse(data["updatedAt"]);
     return {
@@ -6923,7 +7358,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;
   }
@@ -6975,7 +7410,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();
@@ -7024,26 +7459,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. */
@@ -7120,7 +7555,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
@@ -7183,7 +7618,7 @@ ${charter.purpose}
 
 ${charter.purpose}
 
-Route every lesson with one question: about me, my craft, or the user, it goes in memory/core.md; about this codebase, it goes in the project's knowledge directory; something everyone should know, post it.
+Route every lesson with one question: about me, my craft, or the user, it goes in memory/core.md; about how this codebase behaves, it goes in the repo's AGENTS.md or README; about this project as a place (runners, access, flow, where results live), it goes in the project's knowledge; something everyone should know, post it.
 ` + (seed.length === 0 ? "" : `
 ${SEED_INSTRUCTIONS_HEADING}
 
@@ -7200,7 +7635,7 @@ ${seed}
         continue;
       }
       const file = this.paths.agentRole(agent2.name);
-      const body = await exists(file) ? (await readMarkdown(file, z15.record(z15.string(), z15.unknown()))).body : "";
+      const body = await exists(file) ? (await readMarkdown(file, z16.record(z16.string(), z16.unknown()))).body : "";
       const at = body.indexOf(`
 ${SEED_INSTRUCTIONS_HEADING}
 `);
@@ -7239,8 +7674,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"), {});
     }
   }
   /**
@@ -7272,7 +7707,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;
       }
     }
@@ -7492,7 +7927,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     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");
+    const staged = path7.join(this.paths.proposalFiles(proposal2.id), "SKILL.md");
     if (skill2.body === void 0 && (taken === void 0 || !await exists(staged))) {
       throw new BoardError("INVALID_STATE", `proposal ${proposal2.id} holds no skill files`);
     }
@@ -7555,8 +7990,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);
     }
@@ -7614,7 +8049,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()) {
@@ -7646,16 +8082,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`);
@@ -7786,7 +8231,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;
       }
@@ -7892,7 +8337,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.
    */
@@ -7917,7 +8363,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;
       }
@@ -7935,7 +8381,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: [],
@@ -7992,10 +8438,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);
@@ -8075,6 +8521,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.
@@ -8325,7 +8782,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;
@@ -8382,7 +8839,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) {
@@ -8428,7 +8885,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}`,
@@ -8437,7 +8894,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,
@@ -8447,7 +8904,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)
@@ -8455,7 +8912,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
@@ -8463,13 +8920,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`,
@@ -8478,13 +8935,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,
@@ -8497,7 +8954,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}`);
@@ -8507,7 +8964,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) => {
@@ -8516,28 +8973,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}`,
@@ -8547,7 +9004,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),
@@ -8556,7 +9013,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 }
@@ -8565,7 +9022,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
@@ -8574,14 +9031,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,
@@ -8591,7 +9048,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,
@@ -8603,7 +9060,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,
@@ -8613,7 +9070,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
@@ -8621,12 +9078,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,
@@ -8636,13 +9093,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,
@@ -8658,17 +9115,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 }
@@ -8677,7 +9134,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)),
@@ -8686,7 +9143,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 },
@@ -8697,7 +9154,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) => {
@@ -8717,7 +9174,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)];
@@ -8726,7 +9183,7 @@ task.command("list <project>").description("List a project's tasks with their cu
 });
 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();
+  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 },
@@ -8736,7 +9193,7 @@ thread.command("open [taskId]").description("Open a thread on a task, on a propo
   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
@@ -8744,7 +9201,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;
@@ -8752,7 +9209,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 }, () => [
@@ -8763,17 +9220,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}`);
 });
@@ -8781,7 +9238,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()}`;
@@ -8789,13 +9247,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,
@@ -8815,7 +9273,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
@@ -8825,7 +9283,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
@@ -8834,12 +9292,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}`);
@@ -8847,8 +9305,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,
@@ -8859,7 +9317,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()) {
@@ -8874,7 +9332,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
@@ -8883,13 +9341,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,