@kubitnodes/stellaris 0.3.22 → 0.3.24

package/dist/server/index.js

@@ -2,14 +2,14 @@
 
 // apps/server/dist/index.js
 import { access as access2 } from "node:fs/promises";
-import path9 from "node:path";
+import path10 from "node:path";
 import { serve } from "@hono/node-server";
 
 // packages/board-core/dist/board.js
-import { chmod as chmod2, cp, mkdir as mkdir4, readdir as readdir3, readFile as readFile4, rename as rename3, rm as rm2, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
-import path6 from "node:path";
+import { chmod as chmod2, cp, mkdir as mkdir4, readdir as readdir4, readFile as readFile4, rename as rename3, rm as rm2, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
+import path7 from "node:path";
 import { decodeTime, monotonicFactory } from "ulid";
-import { z as 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",
@@ -233,6 +235,7 @@ var CronFrontmatterSchema = z3.object({
   scope: NameSchema,
   thread: UlidSchema.optional(),
   channel: NameSchema.optional(),
+  place: NameSchema.optional(),
   schedule: CronScheduleSchema,
   createdBy: NameSchema,
   createdAt: IsoDateTimeSchema,
@@ -382,15 +385,16 @@ function quotaLevel(quota, now) {
 var WINDOW_NAMES = {
   five_hour: "5h",
   seven_day: "7d",
-  seven_day_opus: "7d Opus",
-  seven_day_sonnet: "7d Sonnet",
+  seven_day_opus: "7d opus",
+  seven_day_sonnet: "7d sonnet",
   seven_day_oauth_apps: "7d apps",
   seven_day_overage_included: "7d extra",
   overage: "extra usage"
 };
 function windowName(window) {
   if (window.label !== void 0) {
-    return window.minutes === 10080 ? `7d ${window.label}` : window.label;
+    const label = window.label.toLowerCase();
+    return window.minutes === 10080 ? `7d ${label}` : label;
   }
   const named = WINDOW_NAMES[window.key];
   if (named !== void 0) {
@@ -989,7 +993,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;
@@ -1037,130 +1042,175 @@ 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"]);
+var IMAGE_MEDIA_TYPES = {
+  png: "image/png",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/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,
@@ -1179,10 +1229,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. */
@@ -1191,8 +1241,12 @@ 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
+  })
 };
 var VERB_DESCRIPTIONS = {
   post_message: "Post a markdown message to a channel, or into a thread when thread_id is given; a thread's message goes to the thread's channel.",
@@ -1203,7 +1257,7 @@ var VERB_DESCRIPTIONS = {
   create_task: "Create a task in a project with its plan: stages of {name, role or agent, gate}. Without stages it gets one stage, work, that anyone in the project may take. File it in a channel of the project, such as a release's, or general by default; its thread opens there with it, under the task's id, for everything said about the work.",
   claim_task: "Hold the task's current stage. Claims are leases renewed by every turn that touches the task.",
   release_task: "Let go of the stage you hold so someone else can take it.",
-  update_task: "Move a task back to an earlier stage, abandon it, set the tasks it is blocked by (blocked_by: its stage wakes nobody until they have all ended), or link its pull request (pull_request: url, with the merge commit's merge_subject and merge_body), which a ghpr task needs before its last stage completes. A note is posted to the task's thread.",
+  update_task: "Move a task back to an earlier stage (the current stage's holder, the user, the steward, or the concierge; anyone else asks the concierge in the task's thread), abandon it, set the tasks it is blocked by (blocked_by: its stage wakes nobody until they have all ended), or link its pull request (pull_request: url, with the merge commit's merge_subject and merge_body), which a ghpr task needs before its last stage completes. A note is posted to the task's thread.",
   get_task: "Read a task with its plan, its brief, and the messages of its thread.",
   subscribe: "Subscribe to a channel. Subscriptions feed your digest; they never wake you.",
   unsubscribe: "Unsubscribe from a channel.",
@@ -1225,11 +1279,12 @@ var VERB_DESCRIPTIONS = {
   create_cron: "Set a cron that wakes you later: a title, a note on what to do then, and either cron, a five-field expression (minute hour day-of-month month day-of-week) read in timezone or the society's, or at, one time. It fires in this turn's conversation unless you name a project, thread_id, or channel, at most every 15 minutes, and every fire is a turn. Only the user, the steward, and the concierge set one that wakes another citizen (agent).",
   update_cron: "Pause or resume a cron, or change its title, note, or schedule; resuming or rescheduling starts it afresh from now. Yours, or anyone's for the user, the steward, and the concierge.",
   remove_cron: "End a cron for good, with a reason. Yours, or anyone's for the user, the steward, and the concierge. A cron also ends with its conversation, and a one-time cron once it fires.",
-  remove_skill: "Remove a skill from the society's skills, with a reason, when it is wrong, superseded, or no longer used: no skills index lists it from the next turn, and a notice in general says so with the reason. Its proposer's own copy stays in its home. Steward and user only; the board keeps its text aside for the user to restore."
+  remove_skill: "Remove a skill from the society's skills, with a reason, when it is wrong, superseded, or no longer used: no skills index lists it from the next turn, and a notice in general says so with the reason. Its proposer's own copy stays in its home. Steward and user only; the board keeps its text aside for the user to restore.",
+  upload_image: "Upload an image file, such as a screenshot or a chart, from the machine your turn runs on: a PNG, JPEG, GIF, or WebP of at most 8 MB, in your worktree, your home, or the system temp folder. Returns its id and the markdown that shows it in a post, `![what it shows](image:<id>)`; write what it shows as the alt text."
 };
 
 // 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",
@@ -1293,21 +1348,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 {
@@ -1317,14 +1373,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 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 = z7.enum([
+var TurnExitReasonSchema = z8.enum([
   "completed",
   "timeout",
   "error",
@@ -1332,50 +1388,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,
@@ -1383,14 +1440,16 @@ 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 RUNNER_PROTOCOL = 1;
 var PATH_TOKENS = {
   home: "{{stellaris:home}}",
@@ -1401,75 +1460,77 @@ var SERVER_TOKEN = "{{stellaris:server}}";
 var WORKSPACE_TOKEN = "{{stellaris:workspace}}";
 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()
 });
 function projectRepo(project) {
   return {
@@ -1479,163 +1540,196 @@ function projectRepo(project) {
     boardLands: project.onDone !== "none"
   };
 }
-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, limit2) {
   if (/^Binary files .* differ$/m.test(patch)) {
@@ -1649,75 +1743,98 @@ function patchHunks(patch, limit2) {
   const cut = hunks.lastIndexOf("\n", limit2);
   return { patch: hunks.slice(0, cut === -1 ? limit2 : 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 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 })
 ]);
 function workspaceConversationOf(turn) {
   if (turn.thread !== void 0) {
     return { kind: "thread", id: turn.thread };
   }
-  return turn.channel === void 0 ? null : { kind: "channel", scope: turn.scope, name: turn.channel };
+  if (turn.channel !== void 0) {
+    return { kind: "channel", scope: turn.scope, name: turn.channel };
+  }
+  return turn.place === void 0 ? null : { kind: "place", project: turn.place };
 }
-var HeldWorkspaceSchema = z8.object({
+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;
@@ -1726,7 +1843,7 @@ function isSafeRelativePath(file) {
 }
 
 // packages/shared/dist/turns.js
-var TriggerKindSchema = z9.enum([
+var TriggerKindSchema = z10.enum([
   "mention",
   "stage",
   "task_done",
@@ -1740,11 +1857,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. */
@@ -1752,20 +1869,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 sessionKey(agent, scope, part) {
   return part === void 0 ? `${agent}/${scope}` : `${agent}/${scope}/${part}`;
@@ -1778,7 +1902,10 @@ function parseSessionKey(key) {
   if (part === void 0) {
     return { agent, scope };
   }
-  return part.startsWith("#") ? { agent, scope, channel: part.slice(1) } : { agent, scope, thread: part };
+  if (part.startsWith("#")) {
+    return { agent, scope, channel: part.slice(1) };
+  }
+  return part.startsWith("~") ? { agent, scope, place: part.slice(1) } : { agent, scope, thread: part };
 }
 function channelConversation(scope, channel) {
   const at = channel.indexOf("/");
@@ -1786,7 +1913,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,
@@ -1795,83 +1926,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",
@@ -1887,7 +2029,7 @@ var OPS_SIGNAL_KINDS = [
   "stuck_workspace",
   "cron_failing"
 ];
-var OpsSignalKindSchema = z10.enum(OPS_SIGNAL_KINDS);
+var OpsSignalKindSchema = z11.enum(OPS_SIGNAL_KINDS);
 var WAKING_SIGNAL_KINDS = [
   "backlog",
   "role_gap",
@@ -1897,15 +2039,15 @@ var WAKING_SIGNAL_KINDS = [
   "blocked_capability",
   "scaled"
 ];
-var OpsSignalSchema = z10.object({
+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(),
@@ -1913,8 +2055,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,
@@ -1925,9 +2067,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,
@@ -1935,12 +2077,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,
@@ -1948,33 +2090,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,
@@ -1982,73 +2124,73 @@ 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)
 });
 function limit(value, fallback) {
   if (value === void 0 || value.trim() === "") {
@@ -2086,25 +2228,25 @@ function loadServerConfig(env) {
     trustedProxies: Number(env["STELLARIS_TRUSTED_PROXIES"] ?? "0")
   });
 }
-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";
@@ -2488,6 +2630,7 @@ var HOME_GITIGNORE = [
   "/projects/*/last-turn.json",
   "/projects/*/threads/",
   "/projects/*/channels/",
+  "/projects/*/places/",
   `/${HOME_SCRATCH}/`,
   "*.tmp",
   "node_modules/",
@@ -2505,7 +2648,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
@@ -2825,32 +2968,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()
+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 = z13.object({
-  taskId: z13.string(),
-  project: z13.string(),
-  from: z13.string().optional()
+var TaskPayload = z14.object({
+  taskId: z14.string(),
+  project: z14.string(),
+  from: z14.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 MessagePayload = z14.object({
+  id: z14.string().optional(),
+  channel: z14.string(),
+  thread: z14.string().nullable().optional(),
+  mentions: z14.array(z14.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()
+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);
@@ -2876,11 +3020,16 @@ function answers(mention, turn) {
   if (!mention.scopes.includes(turn.project)) {
     return false;
   }
-  const own = mention.thread === null ? channelConversation(turn.project, mention.channel) : void 0;
+  const topLevel = mention.thread === null;
+  const own = topLevel ? channelConversation(turn.project, mention.channel) : void 0;
+  const place = topLevel ? placeConversation(turn.project, mention.channel) : void 0;
   if (turn.channel !== null) {
-    return mention.thread === null && own === turn.channel;
+    return topLevel && own === turn.channel;
+  }
+  if (turn.place !== null) {
+    return topLevel && place === turn.place;
   }
-  return mention.thread === null && own === void 0 || turn.trigger === "mention";
+  return topLevel && own === void 0 && place === void 0 || turn.trigger === "mention";
 }
 function computeMetrics(input) {
   const { events, now, window } = input;
@@ -2946,6 +3095,7 @@ function computeMetrics(input) {
           at,
           thread: turn.data.thread ?? null,
           channel: turn.data.channel ?? null,
+          place: turn.data.place ?? null,
           project: turn.data.project,
           trigger: turn.data.trigger
         };
@@ -3140,19 +3290,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) {
@@ -3383,11 +3534,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");
@@ -3398,6 +3552,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");
   }
@@ -3414,6 +3575,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() {
@@ -3427,48 +3683,62 @@ function hashToken(token) {
 var SYSTEM_ACTOR = { name: "board", role: USER_ROLE };
 var CLOSING_ATTEMPTS = 3;
 function ownTurn(actor, turn) {
-  return turn.agent === actor.name && turn.scope === actor.scope && turn.thread === actor.thread && turn.channel === actor.channel;
+  return turn.agent === actor.name && turn.scope === actor.scope && turn.thread === actor.thread && turn.channel === actor.channel && turn.place === actor.place;
 }
 function namesList(names) {
   return names.length <= 1 ? names[0] ?? "" : `${names.slice(0, -1).join(", ")} and ${names.at(-1) ?? ""}`;
 }
 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()
+  news: z16.string().optional()
 });
-var NO_CURSORS = { digest: null, scopes: {}, threadsFrom: {}, channelsFrom: {} };
+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;
@@ -3484,7 +3754,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;
@@ -3492,12 +3762,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(proposal) {
   if (proposal.kind !== "skill") {
     return null;
@@ -3506,7 +3778,7 @@ function skillFolderOf(proposal) {
   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$/, "");
@@ -3517,7 +3789,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";
@@ -3528,13 +3800,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.";
@@ -3601,8 +3875,8 @@ function restage(existing, edit) {
   };
 }
 function reopenStage(stage) {
-  const { completedBy: _by, completedAt: _at, ...open2 } = stage;
-  return open2;
+  const { completedBy: _by, completedAt: _at, ...open3 } = stage;
+  return open3;
 }
 function gateChanges(before, after) {
   const changes = [];
@@ -3666,6 +3940,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();
@@ -3682,7 +3957,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);
@@ -3715,7 +3990,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,
@@ -3730,7 +4005,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;
@@ -3760,13 +4037,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)) {
@@ -3775,6 +4052,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] });
   }
   /**
@@ -3816,12 +4099,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] });
       }
     }
@@ -3979,7 +4262,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;
@@ -3987,7 +4270,7 @@ var Board = class _Board {
         const task = { ...TaskFrontmatterSchema.parse(raw.data), body: raw.body };
         if ((legacy === "open" || legacy === "closed") && !await exists(this.paths.threadFile(threads, task.id))) {
           const ended = task.status === "done" || task.status === "abandoned";
-          const open2 = legacy === "open" && !ended;
+          const open3 = legacy === "open" && !ended;
           const openedBy = opened.get(task.id);
           const closedBy = closed.get(task.id);
           await this.writeThread(threads, {
@@ -3995,10 +4278,10 @@ var Board = class _Board {
             channel: channelRef(slug, "general"),
             title: task.title,
             subject: { kind: "task", id: task.id },
-            state: open2 ? "open" : "closed",
+            state: open3 ? "open" : "closed",
             openedBy: openedBy?.actor ?? task.createdBy,
             openedAt: openedBy?.ts ?? task.createdAt,
-            ...open2 ? {} : {
+            ...open3 ? {} : {
               closedBy: closedBy?.actor ?? SYSTEM_ACTOR.name,
               closedAt: closedBy?.ts ?? this.now().toISOString()
             },
@@ -4030,6 +4313,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 agent of await this.listAgents()) {
+      const file = this.paths.agentCursors(agent.name);
+      if (!await exists(file)) {
+        continue;
+      }
+      const cursors = await readJson(file, CursorsSchema);
+      await writeJson(file, {
+        ...cursors,
+        placesFrom: { [SOCIETY_SCOPE]: cursorOf(cursors, SOCIETY_SCOPE) }
+      });
+    }
+  }
   /**
    * 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
@@ -4057,7 +4358,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 agent of await this.listAgents()) {
       const file = this.paths.agentCursors(agent.name);
       if (await exists(file)) {
@@ -4103,7 +4404,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));
@@ -4170,13 +4471,15 @@ ${charter.purpose}
     const token = mintToken();
     const thread = threadOfPart(part);
     const channel = channelOfPart(part);
+    const place = placeOfPart(part);
     this.turnTokens.set(hashToken(token), {
       actor: {
         name: agent,
         role,
         ...scope === void 0 ? {} : { scope },
         ...thread === void 0 ? {} : { thread },
-        ...channel === void 0 ? {} : { channel }
+        ...channel === void 0 ? {} : { channel },
+        ...place === void 0 ? {} : { place }
       },
       expiresAt: this.now().getTime() + ttlMs
     });
@@ -4265,7 +4568,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();
@@ -4362,7 +4665,7 @@ ${charter.purpose}
     const files = await listFiles(this.paths.tasks(project));
     const tasks = [];
     for (const file of files) {
-      const doc = await readMarkdown(path6.join(this.paths.tasks(project), file), TaskFrontmatterSchema);
+      const doc = await readMarkdown(path7.join(this.paths.tasks(project), file), TaskFrontmatterSchema);
       tasks.push({ ...doc.data, body: doc.body });
     }
     return tasks;
@@ -4381,7 +4684,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;
@@ -4408,7 +4711,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;
@@ -4420,14 +4723,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(project) {
     const dir = project === null ? this.paths.societyKnowledge() : this.paths.projectKnowledge(project);
     const topics = [];
     for (const file of await listFiles(dir)) {
-      topics.push(await this.knowledgeAt(path6.join(dir, file), project, file.replace(/\.md$/, "")));
+      topics.push(await this.knowledgeAt(path7.join(dir, file), project, file.replace(/\.md$/, "")));
     }
     return topics;
   }
@@ -4440,7 +4743,7 @@ ${charter.purpose}
    */
   async knowledgeAt(file, project, 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 {
@@ -4457,7 +4760,7 @@ ${charter.purpose}
     const aside = this.paths.removedKnowledge(project ?? SOCIETY_SCOPE);
     let highest = 0;
     for (const file of (await listFiles(aside)).filter((name) => name.startsWith(`${topic}.`))) {
-      const copy = await this.knowledgeAt(path6.join(aside, file), project, topic);
+      const copy = await this.knowledgeAt(path7.join(aside, file), project, topic);
       highest = Math.max(highest, copy.revision);
     }
     return highest;
@@ -4473,7 +4776,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;
       }
@@ -4563,7 +4866,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) {
@@ -4595,7 +4898,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;
         }
@@ -4622,7 +4925,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({
@@ -4989,16 +5292,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) {
@@ -5008,11 +5315,23 @@ ${DASHBOARD_LINE}
       if (posted !== scope && scope !== SOCIETY_SCOPE) {
         continue;
       }
+      const thread = threadOfPart(part);
+      if (thread !== void 0) {
+        let ended = closed.get(thread);
+        if (ended === void 0) {
+          ended = (await this.tryFindThread(thread))?.thread.state === "closed";
+          closed.set(thread, ended);
+        }
+        if (ended) {
+          continue;
+        }
+      }
       const key = conversationKey(scope, part);
       const entry = counts.get(key) ?? {
         scope,
-        thread: threadOfPart(part) ?? null,
+        thread: thread ?? null,
         channel: channelOfPart(part) ?? null,
+        place: placeOfPart(part) ?? null,
         count: 0
       };
       counts.set(key, { ...entry, count: entry.count + 1 });
@@ -5070,8 +5389,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) {
@@ -5091,11 +5411,17 @@ ${DASHBOARD_LINE}
     const frontDesk = charter.wakeTriggers.includes(FRONT_DESK_TRIGGER);
     const threadParticipation = /* @__PURE__ */ new Map();
     const openChannels = /* @__PURE__ */ new Map();
+    const liveProjects = /* @__PURE__ */ new Map();
     const collected = [];
     const newsFrom = charter.societyScope ? void 0 : newsStart(cursors);
     const scopes = conversation !== void 0 ? [conversation.scope] : [...agent.memberships, SOCIETY_SCOPE];
     const starts = [
-      ...scopes.flatMap((each) => conversation === void 0 ? [cursorOf(cursors, each), threadStart(cursors, each), channelStart(cursors, each)] : [cursorOf(cursors, each, conversation.part)]),
+      ...scopes.flatMap((each) => conversation === void 0 ? [
+        cursorOf(cursors, each),
+        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);
@@ -5105,7 +5431,7 @@ ${DASHBOARD_LINE}
       const thread = message.thread ?? null;
       const asked = message.mentions.includes(actor.name) || frontDesk && message.author === USER_NAME;
       if (newsFrom !== void 0 && thread === null && filedIn === SOCIETY_SCOPE && !asked) {
-        if ((newsFrom === null || message.id > newsFrom) && subscribed.has(message.channel) && message.author !== actor.name) {
+        if ((conversation === void 0 || conversation.part === null) && (newsFrom === null || message.id > newsFrom) && subscribed.has(message.channel) && message.author !== actor.name) {
           collected.push({
             scope: conversation?.scope ?? SOCIETY_SCOPE,
             part: null,
@@ -5116,12 +5442,18 @@ ${DASHBOARD_LINE}
         continue;
       }
       const named = thread === null ? channelConversation(filedIn, message.channel) : void 0;
-      let open2 = named === void 0 ? void 0 : openChannels.get(message.channel);
-      if (named !== void 0 && open2 === void 0) {
-        open2 = await this.channelOpen(message.channel);
-        openChannels.set(message.channel, open2);
-      }
-      const part = thread ?? (open2 === true ? `#${named}` : null);
+      let open3 = named === void 0 ? void 0 : openChannels.get(message.channel);
+      if (named !== void 0 && open3 === void 0) {
+        open3 = await this.channelOpen(message.channel);
+        openChannels.set(message.channel, open3);
+      }
+      const project = thread === null ? placeConversation(filedIn, message.channel) : void 0;
+      let live = project === void 0 ? void 0 : liveProjects.get(project);
+      if (project !== void 0 && live === void 0) {
+        live = await this.projectLive(project);
+        liveProjects.set(project, live);
+      }
+      const part = thread ?? (open3 === true ? `#${named}` : live === true ? `~${project}` : null);
       if (conversation !== void 0 && (filedIn !== conversation.scope || part !== conversation.part)) {
         continue;
       }
@@ -5186,7 +5518,7 @@ ${task.body}`;
         }
       }
       for (const file of await listFiles(this.paths.projectKnowledge(project))) {
-        const content = await readFile4(path6.join(this.paths.projectKnowledge(project), file), "utf8");
+        const content = await readFile4(path7.join(this.paths.projectKnowledge(project), file), "utf8");
         if (content.toLowerCase().includes(needle)) {
           hits.push({
             kind: "knowledge",
@@ -5207,7 +5539,7 @@ ${task.body}`;
       shared.push({
         kind: "knowledge",
         ref: `society/knowledge/${file}`,
-        file: path6.join(this.paths.societyKnowledge(), file)
+        file: path7.join(this.paths.societyKnowledge(), file)
       });
     }
     for (const skill of await this.listSocietySkills()) {
@@ -5220,7 +5552,7 @@ ${task.body}`;
       shared.push({
         kind: "memory",
         ref: `memory/${file}`,
-        file: path6.join(this.paths.agentMemory(actor.name), file)
+        file: path7.join(this.paths.agentMemory(actor.name), file)
       });
     }
     for (const entry of shared) {
@@ -5310,7 +5642,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
@@ -5358,7 +5690,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
@@ -5403,11 +5735,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;
   }
@@ -5529,11 +5915,16 @@ ${current.body}`);
   }
   /**
    * Where a cron fires for its citizen: the thread, the channel, or the scope's home it names, else
-   * the conversation of the turn that set it when it wakes its setter, else its home outside projects.
+   * the conversation of the turn that set it when it wakes its setter, a project's channels' in
+   * the society scope included, else its home outside projects.
    */
   async cronConversation(actor, agent, named) {
     const own = actor.name === agent.name;
     if (named.project === void 0 && named.thread_id === void 0 && named.channel === void 0) {
+      if (own && actor.scope === SOCIETY_SCOPE && actor.place !== void 0) {
+        await this.readActiveProject(actor.place);
+        return { scope: SOCIETY_SCOPE, place: actor.place };
+      }
       return own && actor.scope !== void 0 ? this.cronConversation(actor, agent, {
         project: actor.scope,
         thread_id: actor.thread,
@@ -5609,7 +6000,8 @@ ${current.body}`);
       agent: cron.agent,
       project: cron.scope,
       ...cron.thread === void 0 ? {} : { thread: cron.thread },
-      ...cron.channel === void 0 ? {} : { channel: cron.channel }
+      ...cron.channel === void 0 ? {} : { channel: cron.channel },
+      ...cron.place === void 0 ? {} : { place: cron.place }
     };
   }
   async readCronFile(file) {
@@ -5794,6 +6186,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
@@ -5813,17 +6212,20 @@ ${current.body}`);
   async openThreadIds(dir, keep) {
     const ids = /* @__PURE__ */ new Set();
     for (const file of await listFiles(dir)) {
-      const doc = await readMarkdown(path6.join(dir, file), ThreadFrontmatterSchema);
+      const doc = await readMarkdown(path7.join(dir, file), ThreadFrontmatterSchema);
       if (doc.data.state === "open" && keep({ ...doc.data, body: doc.body })) {
         ids.add(doc.data.id);
       }
     }
     return ids;
   }
-  /** Refuses to archive a project while a turn runs in it or in a thread its archive closes. */
+  /**
+   * Refuses to archive a project while a turn runs in it, in a citizen's conversation of its
+   * channels in the society scope, or in a thread its archive closes.
+   */
   async assertProjectQuiet(actor, slug) {
     const threads = await this.openThreadIds(this.paths.threads(slug), () => true);
-    this.assertNoTurnCut(actor, `project ${slug} cannot be archived`, (turn) => turn.scope === slug || turn.thread !== void 0 && threads.has(turn.thread));
+    this.assertNoTurnCut(actor, `project ${slug} cannot be archived`, (turn) => turn.scope === slug || turn.place === slug || turn.thread !== void 0 && threads.has(turn.thread));
   }
   async closeThread(actor, input) {
     const args = VerbInputs.close_thread.parse(input);
@@ -6364,7 +6766,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
@@ -6623,6 +7026,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)}`);
     }
@@ -6669,7 +7074,7 @@ ${rationale}`}`);
   }
   async readAgentRoleBody(agent) {
     const file = this.paths.agentRole(agent);
-    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. */
   /**
@@ -6774,19 +7179,20 @@ ${rationale}`}`);
         project: input.project,
         ...input.thread === void 0 ? {} : { thread: input.thread },
         ...input.channel === void 0 ? {} : { channel: input.channel },
+        ...input.place === void 0 ? {} : { place: input.place },
         messages: [...input.messages]
       });
     });
   }
   /**
    * Where a conversation's session ids and last turn are kept: the scope's home, or beside it a
-   * thread's or a channel's, named by `part` as `conversationPart` gives it.
+   * thread's, a channel's, or a project's, named by `part` as `conversationPart` gives it.
    */
   sessionDir(agent, scope, part) {
     return part === void 0 ? this.paths.agentProject(agent, scope) : this.paths.agentConversation(agent, scope, part);
   }
   async readSessions(agent, project, part) {
-    const file = path6.join(this.sessionDir(agent, project, part), "sessions.json");
+    const file = path7.join(this.sessionDir(agent, project, part), "sessions.json");
     return await exists(file) ? readJson(file, SessionsFileSchema) : {};
   }
   /**
@@ -6797,15 +7203,34 @@ ${rationale}`}`);
     await this.mutex.run(async () => {
       const dir = this.sessionDir(agent, project, part);
       await ensureDir(dir);
-      const file = path6.join(dir, "sessions.json");
+      const file = path7.join(dir, "sessions.json");
       const current = await exists(file) ? await readJson(file, SessionsFileSchema) : {};
       const kept = current.runner === void 0 || current.runner === runner ? current : {};
       await writeJson(file, { ...kept, [cli]: sessionId, runner });
     });
   }
-  /** The last turn of one conversation: the scope's home, a channel's, or a thread's. */
+  /**
+   * Drops a conversation's session for a CLI, so its next turn starts a new one, when the record
+   * still names `sessionId`; returns whether it did.
+   */
+  async dropSession(agent, project, cli, sessionId, part) {
+    return this.mutex.run(async () => {
+      const file = path7.join(this.sessionDir(agent, project, part), "sessions.json");
+      if (!await exists(file)) {
+        return false;
+      }
+      const current = await readJson(file, SessionsFileSchema);
+      if (current[cli] !== sessionId) {
+        return false;
+      }
+      const { [cli]: _dropped, ...kept } = current;
+      await writeJson(file, kept);
+      return true;
+    });
+  }
+  /** The last turn of one conversation: the scope's home, a channel's, a project's, or a thread's. */
   async readLastTurn(agent, project, part) {
-    const file = path6.join(this.sessionDir(agent, project, part), "last-turn.json");
+    const file = path7.join(this.sessionDir(agent, project, part), "last-turn.json");
     return await exists(file) ? readJson(file, TurnRecordSchema) : null;
   }
   /** The latest turn a citizen took in a scope, in any of its conversations there. */
@@ -6813,8 +7238,9 @@ ${rationale}`}`);
     let latest = await this.readLastTurn(agent, project);
     const place = this.paths.agentProject(agent, project);
     const parts = [
-      ...await listDirs(path6.join(place, "threads")),
-      ...(await listDirs(path6.join(place, "channels"))).map((name) => `#${name}`)
+      ...await listDirs(path7.join(place, "threads")),
+      ...(await listDirs(path7.join(place, "channels"))).map((name) => `#${name}`),
+      ...(await listDirs(path7.join(place, "places"))).map((name) => `~${name}`)
     ];
     for (const part of parts) {
       const turn = await this.readLastTurn(agent, project, part);
@@ -6835,6 +7261,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
@@ -6864,7 +7291,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, {
@@ -6872,6 +7300,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,
@@ -6881,7 +7310,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 } : {}
       });
     });
   }
@@ -6918,6 +7349,20 @@ ${rationale}`}`);
       return task;
     });
   }
+  /**
+   * Posts the board's word on a task's work into the task's thread, such as commits a runner
+   * could not put on its branch: as the board, with every `@name` written as a plain name, so it
+   * wakes nobody and counts toward no heartbeat. Null, posting nothing, once the thread is closed.
+   */
+  async postTaskNotice(taskId, body) {
+    return this.mutex.run(async () => {
+      const found = await this.tryFindThread(taskId);
+      if (found === null || found.thread.state !== "open") {
+        return null;
+      }
+      return this.appendThreadMessage(SYSTEM_ACTOR.name, taskId, withoutMentions(body));
+    });
+  }
   /**
    * Records that a citizen's workspace in a conversation that has ended holds work on no branch, so
    * the scheduler gives the citizen a closing turn there to decide about it. False, recording
@@ -6928,7 +7373,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;
@@ -6980,9 +7425,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));
@@ -7056,11 +7505,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) {
@@ -7077,7 +7526,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 {
@@ -7091,7 +7540,7 @@ ${rationale}`}`);
   async listRunners() {
     const runners2 = [];
     for (const file of await listFiles(this.paths.runners())) {
-      runners2.push((await readMarkdown(path6.join(this.paths.runners(), file), RunnerSchema)).data);
+      runners2.push((await readMarkdown(path7.join(this.paths.runners(), file), RunnerSchema)).data);
     }
     return runners2;
   }
@@ -7143,7 +7592,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();
@@ -7192,26 +7641,26 @@ ${rationale}`}`);
   async listHomeConflicts(agent) {
     const home = this.paths.agent(agent);
     const found = [];
-    const walk = async (dir, prefix) => {
-      for (const entry of await readdir3(dir, { withFileTypes: true }).catch(() => [])) {
+    const walk2 = async (dir, prefix) => {
+      for (const entry of await readdir4(dir, { withFileTypes: true }).catch(() => [])) {
         if (prefix === "" && SKIPPED_IN_HOME.has(entry.name)) {
           continue;
         }
         const relative = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
         if (entry.isDirectory()) {
-          await walk(path6.join(dir, entry.name), relative);
+          await walk2(path7.join(dir, entry.name), relative);
           continue;
         }
         const file = entry.isFile() ? conflictCopyOf(relative) : null;
         if (file !== null) {
-          const since = await this.homes.changedAt(home, relative) ?? (await stat3(path6.join(home, relative)).catch(() => null))?.mtime.toISOString();
+          const since = await this.homes.changedAt(home, relative) ?? (await stat3(path7.join(home, relative)).catch(() => null))?.mtime.toISOString();
           if (since !== void 0) {
             found.push({ path: relative, file, since });
           }
         }
       }
     };
-    await walk(home, "");
+    await walk2(home, "");
     return found.toSorted((a, b) => a.path.localeCompare(b.path));
   }
   /** The newest `limit` changes to an agent's home, newest first; empty while it is no repository. */
@@ -7288,7 +7737,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
@@ -7351,7 +7800,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}
 
@@ -7368,7 +7817,7 @@ ${seed}
         continue;
       }
       const file = this.paths.agentRole(agent.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}
 `);
@@ -7407,8 +7856,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"), {});
     }
   }
   /**
@@ -7440,7 +7889,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       const at = turn?.endedAt ?? turn?.startedAt;
       if (turn !== null && at !== void 0 && (lastTurnAt === void 0 || at > lastTurnAt)) {
         lastTurnAt = at;
-        lastTurnOutcome = `${turn.trigger.kind} on ${scope}: ${turn.exitReason ?? "running"}${turn.status === null ? "" : `, ${turn.status.summary.slice(0, 160)}`}`;
+        lastTurnOutcome = `${turn.trigger.kind} on ${scope}${turnConversation(turn)}: ${turn.exitReason ?? "running"}${turn.status === null ? "" : `, ${turn.status.summary.slice(0, 160)}`}`;
         lastModel = turn.model ?? void 0;
       }
     }
@@ -7660,7 +8109,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     const file = this.paths.societySkillFile(skill.name);
     const replaced = await exists(file);
     const taken = proposal.skillFiles;
-    const staged = path6.join(this.paths.proposalFiles(proposal.id), "SKILL.md");
+    const staged = path7.join(this.paths.proposalFiles(proposal.id), "SKILL.md");
     if (skill.body === void 0 && (taken === void 0 || !await exists(staged))) {
       throw new BoardError("INVALID_STATE", `proposal ${proposal.id} holds no skill files`);
     }
@@ -7723,8 +8172,8 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     const dir = this.paths.proposalFiles(proposal.id);
     await rm2(dir, { recursive: true, force: true });
     for (const entry of taken.files) {
-      const target = path6.join(dir, ...entry.path.split("/"));
-      await ensureDir(path6.dirname(target));
+      const target = path7.join(dir, ...entry.path.split("/"));
+      await ensureDir(path7.dirname(target));
       await writeFile4(target, contents.get(entry.path) ?? Buffer.alloc(0));
       await chmod2(target, entry.executable ? 493 : 420);
     }
@@ -7782,7 +8231,8 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     const where = {
       scope: turn.project,
       ...turn.thread === void 0 ? {} : { thread: turn.thread },
-      ...turn.channel === void 0 ? {} : { channel: turn.channel }
+      ...turn.channel === void 0 ? {} : { channel: turn.channel },
+      ...turn.place === void 0 ? {} : { place: turn.place }
     };
     await this.mutex.run(async () => {
       for (const proposal of await this.listProposals()) {
@@ -7814,16 +8264,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`);
@@ -7954,7 +8413,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     this.assertNoTurnCut(actor, `${ref} cannot be archived`, (turn) => turn.channel === channel && turn.scope === scope || turn.thread !== void 0 && closing.has(turn.thread));
     const threadsClosed = [];
     for (const file of await listFiles(threads)) {
-      const doc = await readMarkdown(path6.join(threads, file), ThreadFrontmatterSchema);
+      const doc = await readMarkdown(path7.join(threads, file), ThreadFrontmatterSchema);
       if (doc.data.channel !== ref || doc.data.state !== "open") {
         continue;
       }
@@ -8060,7 +8519,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.
    */
@@ -8085,7 +8545,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;
       }
@@ -8103,7 +8563,7 @@ ${charter.purpose}
       });
       threadsClosed.push(doc.data.id);
     }
-    await this.endCronsUnlocked(by, `project ${slug} was archived`, (cron) => cron.scope === slug || cron.thread !== void 0 && threadsClosed.includes(cron.thread));
+    await this.endCronsUnlocked(by, `project ${slug} was archived`, (cron) => cron.scope === slug || cron.place === slug || cron.thread !== void 0 && threadsClosed.includes(cron.thread));
     const project = await this.updateProject(slug, (p) => ({
       ...p,
       members: [],
@@ -8160,10 +8620,10 @@ ${charter.purpose}
         ...project,
         members: project.members.filter((member) => member !== name)
       }));
-      const sessions = path6.join(this.paths.agentProject(name, slug), "sessions.json");
+      const sessions = path7.join(this.paths.agentProject(name, slug), "sessions.json");
       if (await exists(sessions)) {
         const archived = `sessions.archived.${ts.replace(/[:.]/g, "-")}.json`;
-        await rename3(sessions, path6.join(this.paths.agentProject(name, slug), archived));
+        await rename3(sessions, path7.join(this.paths.agentProject(name, slug), archived));
       }
     }
     this.tokenIndex.delete(current.tokenHash);
@@ -8243,6 +8703,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.
@@ -8493,7 +8964,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;
@@ -8584,16 +9055,26 @@ function decideWake(input) {
 }
 
 // packages/scheduler/dist/scheduler.js
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 function besideFields(beside) {
   if (beside === void 0) {
     return {};
   }
-  return "thread" in beside ? { thread: beside.thread } : { channel: beside.channel };
+  if ("thread" in beside) {
+    return { thread: beside.thread };
+  }
+  return "channel" in beside ? { channel: beside.channel } : { place: beside.place };
+}
+function namedIn(dispatch) {
+  return {
+    ...dispatch.thread === void 0 ? {} : { thread: dispatch.thread.id },
+    ...dispatch.channel === void 0 ? {} : { channel: dispatch.channel },
+    ...dispatch.place === void 0 ? {} : { place: dispatch.place }
+  };
 }
 function conversationKey2(agent, scope, beside) {
   const fields = besideFields(beside);
-  return sessionKey(agent, scope, conversationPart({ thread: fields.thread?.id, channel: fields.channel }));
+  return sessionKey(agent, scope, conversationPart({ thread: fields.thread?.id, channel: fields.channel, place: fields.place }));
 }
 var DEFAULT_TIMINGS = Object.freeze({
   pollMs: 1e3,
@@ -8611,21 +9092,21 @@ var DEFAULT_TIMINGS = Object.freeze({
   scaleCooldownMs: 36e5,
   reflectionMs: 24 * 36e5
 });
-var SchedulerTimingsSchema = z16.object({
-  pollMs: z16.number().positive(),
-  debounceMs: z16.number().nonnegative(),
-  userDebounceMs: z16.number().nonnegative(),
-  heartbeatMs: z16.number().positive(),
-  waitingStageMs: z16.number().positive(),
-  leaseSweepMs: z16.number().positive(),
-  opsIntervalMs: z16.number().positive(),
-  signalRepeatMs: z16.number().positive(),
-  costReportMs: z16.number().positive(),
-  staleThreadMs: z16.number().positive(),
-  idleMemberMs: z16.number().positive(),
-  homeConflictMs: z16.number().positive(),
-  scaleCooldownMs: z16.number().positive(),
-  reflectionMs: z16.number().positive()
+var SchedulerTimingsSchema = z17.object({
+  pollMs: z17.number().positive(),
+  debounceMs: z17.number().nonnegative(),
+  userDebounceMs: z17.number().nonnegative(),
+  heartbeatMs: z17.number().positive(),
+  waitingStageMs: z17.number().positive(),
+  leaseSweepMs: z17.number().positive(),
+  opsIntervalMs: z17.number().positive(),
+  signalRepeatMs: z17.number().positive(),
+  costReportMs: z17.number().positive(),
+  staleThreadMs: z17.number().positive(),
+  idleMemberMs: z17.number().positive(),
+  homeConflictMs: z17.number().positive(),
+  scaleCooldownMs: z17.number().positive(),
+  reflectionMs: z17.number().positive()
 }).partial();
 function parseTimings(input) {
   const parsed = SchedulerTimingsSchema.parse(input);
@@ -8637,32 +9118,32 @@ function parseTimings(input) {
   }
   return overrides;
 }
-var PendingSchema = z16.object({
+var PendingSchema = z17.object({
   dispatch: TurnDispatchSchema,
-  readyAt: z16.number(),
-  stageWakes: z16.array(TriggerSchema).optional(),
-  holder: z16.boolean().optional(),
+  readyAt: z17.number(),
+  stageWakes: z17.array(TriggerSchema).optional(),
+  holder: z17.boolean().optional(),
   newestMessage: UlidSchema.optional(),
-  onlyMessages: z16.boolean().optional(),
+  onlyMessages: z17.boolean().optional(),
   steeredThrough: UlidSchema.optional(),
-  onlyCrons: z16.boolean().optional()
+  onlyCrons: z17.boolean().optional()
 });
-var StateSchema = z16.object({
-  cursor: z16.string().nullable(),
-  lastHeartbeat: z16.record(z16.string(), z16.string()),
+var StateSchema = z17.object({
+  cursor: z17.string().nullable(),
+  lastHeartbeat: z17.record(z17.string(), z17.string()),
   /** Waiting stages already signalled, as `task:stage`, so each is logged once while it waits. */
-  waitingSeen: z16.record(z16.string(), z16.string()).default({}),
+  waitingSeen: z17.record(z17.string(), z17.string()).default({}),
   /** Queued dispatches survive a restart; the cursor has already moved past the events that made them. */
-  pending: z16.record(z16.string(), PendingSchema).default({}),
-  opsReported: z16.record(z16.string(), z16.string()).default({}),
-  releaseCounts: z16.record(z16.string(), z16.number().int().nonnegative()).default({}),
-  lastOps: z16.string().nullable().default(null),
-  lastScaled: z16.record(z16.string(), z16.string()).default({}),
-  lastCostReport: z16.string().nullable().default(null),
-  costSinceReport: z16.number().nonnegative().default(0),
-  turnsSinceReport: z16.number().int().nonnegative().default(0),
+  pending: z17.record(z17.string(), PendingSchema).default({}),
+  opsReported: z17.record(z17.string(), z17.string()).default({}),
+  releaseCounts: z17.record(z17.string(), z17.number().int().nonnegative()).default({}),
+  lastOps: z17.string().nullable().default(null),
+  lastScaled: z17.record(z17.string(), z17.string()).default({}),
+  lastCostReport: z17.string().nullable().default(null),
+  costSinceReport: z17.number().nonnegative().default(0),
+  turnsSinceReport: z17.number().int().nonnegative().default(0),
   /** When each member last reflected, or was first seen; the cadence counts from here. */
-  lastReflection: z16.record(z16.string(), z16.string()).default({})
+  lastReflection: z17.record(z17.string(), z17.string()).default({})
 });
 function messageOf(trigger) {
   return trigger.kind === "mention" || trigger.kind === "user_post" ? trigger.messageId : void 0;
@@ -9065,6 +9546,21 @@ var Scheduler = class {
         }
         return;
       }
+      case "project.archived": {
+        const slug = stringOf(payload["slug"]);
+        if (slug === null) {
+          return;
+        }
+        this.sweep({ kind: "place", project: slug });
+        for (const [key, item] of this.pending) {
+          const { dispatch } = item;
+          if (dispatch.place === slug) {
+            this.pending.delete(key);
+            this.log.info({ agent: dispatch.agent, project: dispatch.project, place: slug }, "dropping project wake, the project is archived");
+          }
+        }
+        return;
+      }
       case "agent.left": {
         const name = stringOf(payload["name"]);
         const project = stringOf(payload["project"]);
@@ -9366,11 +9862,12 @@ var Scheduler = class {
     const scope = stringOf(payload["project"]);
     const thread = stringOf(payload["thread"]);
     const channel = stringOf(payload["channel"]);
+    const place = stringOf(payload["place"]);
     const agent = name === null ? null : await this.tryReadAgent(name);
     if (agent === null || scope === null) {
       return;
     }
-    const beside = thread !== null ? { thread: await this.conversationOf(thread, scope) } : channel !== null ? { channel } : null;
+    const beside = thread !== null ? { thread: await this.conversationOf(thread, scope) } : channel !== null ? { channel } : place !== null ? { place } : null;
     if (beside === null) {
       return;
     }
@@ -9415,7 +9912,7 @@ var Scheduler = class {
     }
     return {
       scope,
-      beside: conversation.kind === "thread" ? { thread: await this.conversationOf(conversation.id, scope) } : { channel: conversation.name }
+      beside: conversation.kind === "thread" ? { thread: await this.conversationOf(conversation.id, scope) } : conversation.kind === "channel" ? { channel: conversation.name } : { place: conversation.project }
     };
   }
   /**
@@ -9433,14 +9930,23 @@ var Scheduler = class {
   }
   /**
    * The conversation a post wakes a citizen in, for a turn in `scope`: its thread's, else its
-   * channel's when that is a channel of the scope other than general, else the scope's home.
+   * channel's when that is a channel of the scope other than general, else, for a turn in the
+   * society scope, its project's when it is a project's channel, general included, else the
+   * scope's home.
    */
   async postedIn(scope, channel, threadId) {
     if (threadId !== void 0) {
       return { thread: await this.conversationOf(threadId, scope) };
     }
-    const name = channel === null ? void 0 : channelConversation(scope, channel);
-    return name === void 0 ? void 0 : { channel: name };
+    if (channel === null) {
+      return void 0;
+    }
+    const name = channelConversation(scope, channel);
+    if (name !== void 0) {
+      return { channel: name };
+    }
+    const place = placeConversation(scope, channel);
+    return place === void 0 ? void 0 : { place };
   }
   async tryReadAgent(name) {
     try {
@@ -9582,7 +10088,7 @@ var Scheduler = class {
         };
         for (const entry of unread) {
           if (entry.scope === project) {
-            const beside = entry.thread !== null ? { thread: await this.conversationOf(entry.thread, project) } : entry.channel !== null ? { channel: entry.channel } : void 0;
+            const beside = entry.thread !== null ? { thread: await this.conversationOf(entry.thread, project) } : entry.channel !== null ? { channel: entry.channel } : entry.place !== null ? { place: entry.place } : void 0;
             reasonsIn(beside).digestSize += entry.count;
           }
         }
@@ -9669,7 +10175,10 @@ var Scheduler = class {
     if (cron.thread !== void 0) {
       return { thread: await this.conversationOf(cron.thread, cron.scope) };
     }
-    return cron.channel === void 0 ? void 0 : { channel: cron.channel };
+    if (cron.channel !== void 0) {
+      return { channel: cron.channel };
+    }
+    return cron.place === void 0 ? void 0 : { place: cron.place };
   }
   /** Whether a cron's wake waits in the queue or its turn is running. */
   cronQueuedOrRunning(id) {
@@ -10054,8 +10563,7 @@ var Scheduler = class {
       const attempt = steer({
         agent: dispatch.agent,
         project: dispatch.project,
-        ...dispatch.thread === void 0 ? {} : { thread: dispatch.thread.id },
-        ...dispatch.channel === void 0 ? {} : { channel: dispatch.channel }
+        ...namedIn(dispatch)
       }).then((outcome) => {
         const current = this.pending.get(key);
         if (outcome !== "busy" && current !== void 0) {
@@ -10076,7 +10584,7 @@ var Scheduler = class {
       return false;
     }
     const { dispatch } = item;
-    const cursor = await this.board.digestCursor(dispatch.agent, dispatch.project, conversationPart({ thread: dispatch.thread?.id, channel: dispatch.channel }));
+    const cursor = await this.board.digestCursor(dispatch.agent, dispatch.project, conversationPart(namedIn(dispatch)));
     return cursor !== null && cursor >= item.newestMessage;
   }
   async dispatchReady(now) {
@@ -10113,6 +10621,7 @@ var Scheduler = class {
         project: dispatch.project,
         thread: dispatch.thread?.id,
         channel: dispatch.channel,
+        place: dispatch.place,
         trigger: dispatch.trigger.kind
       }, "dispatching turn");
       const crons = dispatch.crons ?? [];
@@ -10229,17 +10738,17 @@ import { randomUUID } from "node:crypto";
 
 // packages/turn-host/dist/render.js
 var TURN_CONTRACT = [
-  "- Every turn belongs to one conversation, named at the top of your prompt: your home conversation in a project or the society, for its general channel and for work tied to no other channel and no thread; the conversation of one other channel of the place, a workstream such as a release; or the conversation of one thread you take part in, a task's, a proposal's, or a topic's. Each has its own session and its own turns, which may run while this one does. The prompt carries this conversation only: in a thread, its new messages, or the whole thread when the conversation is new, and in a task's thread the task and its stage; in a channel's or at home, that channel's or general's messages that concern you. Read anything else you need with get_task, search, and the board's files, and leave other channels', other threads', and other projects' work to their own turns.",
+  "- Every turn belongs to one conversation, named at the top of your prompt: your home conversation in a project or the society, for its general channel and for work tied to no other channel and no thread; the conversation of one other channel of the place, a workstream such as a release; outside projects, the conversation of one project's channels, general and its workstreams together, for posts there that ask something of you while you are not a member; or the conversation of one thread you take part in, a task's, a proposal's, or a topic's. Each has its own session and its own turns, which may run while this one does. The prompt carries this conversation only: in a thread, its new messages, or the whole thread when the conversation is new, and in a task's thread the task and its stage; in a channel's, a project's, or at home, that channel's, that project's channels', or general's messages that concern you. Read anything else you need with get_task, search, and the board's files, and leave other channels', other threads', and other projects' work to their own turns.",
   "- Act through the board tools (the `board` MCP server). Holding a stage is a lease; every turn that touches the task renews it.",
-  "- Work only inside your worktree. In a task's conversation it is a worktree of its own on the task's branch `task/<id>`: commit your work there. After each turn the runner commits what you left on the branch and lets it go for the next holder. Your home worktree is on your own branch, `agent/<name>`, for work tied to no task; nothing lands from it by itself. In a proposal's, a topic's, or a channel's conversation it is a worktree of its own, detached at the project's default branch, which goes when the thread closes or the channel is archived, so work that should last goes on a task's branch. Before each turn the runner fetches the project's remote and brings what holds no work of yours up to the default branch: your own branch when it has no commits of its own, a task's branch nobody has worked on, and a detached worktree with nothing uncommitted; what it leaves where it is, and why, is under Your workspace in the prompt. It never merges or commits for you.",
+  "- Work only inside your worktree. In a task's conversation it is a worktree of its own on the task's branch `task/<id>`: commit your work there. The branch is checked out in one worktree at a time and kept for the turns of whoever holds the task's stage, so a turn of anyone else there, or one that starts while another turn has the branch, works detached at its tip, which Your workspace then says; its commits go on the branch by a fast-forward when a turn in the task ends with the branch free, and the task's thread is told of commits that no longer build on its tip. After each turn the runner commits what you left on the branch and lets it go for the next holder. Your home worktree is on your own branch, `agent/<name>`, for work tied to no task; nothing lands from it by itself. In a proposal's, a topic's, or a channel's conversation it is a worktree of its own, detached at the project's default branch, which goes when the thread closes or the channel is archived, so work that should last goes on a task's branch. Before each turn the runner fetches the project's remote and brings what holds no work of yours up to the default branch: your own branch when it has no commits of its own, a task's branch nobody has worked on, and a detached worktree with nothing uncommitted; what it leaves where it is, and why, is under Your workspace in the prompt. It never merges or commits for you.",
   "- Posts that would wake this conversation may arrive while you work, delivered into the turn under a heading that says so and formatted like the digest. They are part of this turn: act on them now, after the step in hand, or not at all, as with the digest. The user may also stop a turn; the next turn is told.",
   "- Silence is allowed. If the digest needs no reply, post nothing.",
   "- To come back to something later, set a cron with create_cron: a note on what to do then, and a five-field cron expression or one time with at. It wakes you in this conversation unless you name another, at most every fifteen minutes, and every fire is a paid turn, so end a cron with remove_cron once it has done its job. Never wait by holding a stage, sleeping, or leaving a process running: a turn's board token ends with the turn, so nothing it leaves behind can act on the board. The society's crons are under society/crons/ in the board projection.",
   "- An @mention wakes the citizen named, and every wake costs a turn. Address someone with @ only when you need them to act; when you merely refer to citizens, write their names plainly. A name in a code span or a code block is no mention, so code keeps its @ as written. @user wakes nobody, since the user takes no turns; it is what puts a question before the user, so use it only when you need the user to answer or decide.",
   "- A thread is a conversation off a channel that reaches only its participants and whoever is mentioned in it. Every task has one, opened with it under the task's id on the channel of its project it was filed in, general unless it was filed in another: talk about a task there, with post_message and its thread_id, and the notes you give advance_task and update_task are posted there as you. Its participants are the task's creator, its stage holders and assignees, whoever may take the stage that waits, and anyone who posted; it closes when the task ends. Every proposal has one too, in governance, opened with its pitch and closed by its decision. Open other threads with open_thread on a channel with a title, for any other topic; close_thread posts your summary to its channel.",
-  "- To show an image in a post, such as a screenshot or a chart, commit the file to a task's branch and link it by its path in the task's worktree, as `![what it shows](<path>)`: the board shows a file on a task's branch in place once it is committed, at the latest when your turn ends. An image at an https address shows too. Never put an image or any other file into a message as base64 or a data: URL: the board does not show it, and every reader of the conversation gets it in full in their prompt.",
-  "- Route every lesson: about you, your craft, or the user, write it to memory/core.md in your home directory, and keep that file short by moving detail to memory/<topic>.md, your archive; a durable fact about a project's codebase or process goes through `write_knowledge` on that project; something the whole project should know now, post it to the project channel, and anything about one task, in the task's thread.",
-  '- A procedure you have followed twice is a skill: write it to skills/<name>/SKILL.md in your home, frontmatter with `name` and a one-line `description` and then the steps, and your skills index lists it from the next turn. Files the steps use, such as scripts/ and references/, go in the same folder, named in SKILL.md by paths relative to it. Propose it with kind "skill" when the whole society would use it.',
+  "- To show an image in a post, such as a screenshot or a chart, save it anywhere you can read it, such as a folder from `mktemp -d`, call upload_image with its path, and put the markdown it returns in the post, `![what it shows](image:<id>)`, with what the image shows as its alt text: the board keeps the image, so it shows in any conversation after the file is gone. It takes a PNG, JPEG, GIF, or WebP of at most 8 MB from your worktree, your home, or the system temp folder. An image committed on a task's branch, linked by its path in the task's worktree, still shows in place, and so does one at an https address. Never put an image or any other file into a message as base64 or a data: URL: the board does not show it, and every reader of the conversation gets it in full in their prompt.",
+  "- Route every lesson: about you, your craft, or the user, write it to memory/core.md in your home directory, and keep that file short by moving detail to memory/<topic>.md, your archive; how a codebase behaves (architecture, conventions, gotchas, how to build, test, and verify it) goes in its AGENTS.md or README, committed on a task's branch like any change to the code, or proposed in the task's thread or the project channel when it is outside the task at hand; a durable fact about a project as a place (runners, access, flow, where results live) goes through `write_knowledge` on that project; something the whole project should know now, post it to the project channel, and anything about one task, in the task's thread.",
+  '- A procedure you have followed twice is a candidate for a skill, which it is when it makes a citizen better at a kind of work on any project: write it to skills/<name>/SKILL.md in your home, frontmatter with `name` and a one-line `description` and then the steps, and your skills index lists it from the next turn. Files the steps use, such as scripts/ and references/, go in the same folder, named in SKILL.md by paths relative to it. Propose it with kind "skill" when more than one citizen would use it and nothing in it is tied to one place; a skill only you use stays yours, however many projects you use it on.',
   "- To take a published skill for yourself, install it in a temporary folder and copy it into your home: in a folder from `mktemp -d`, `npx -y skills add <source> --skill <name> -a universal --copy -y` writes `.agents/skills/<name>/` and a lock file there, and you copy that skill folder to skills/<name>/ in your home, named in lowercase letters, digits, and hyphens. Never install one inside a worktree, where it would be committed into the project, or with -g, which writes to the runner's own home, shared by every citizen on it and listed in no skills index.",
   "- Report memoryUpdated: true in the status object whenever you changed memory/core.md or a skill, so a warm session restarts with the new instructions.",
   "- Other turns of yours may be running at the same time and share your home. Change a file there with your edit tool, which refuses a file changed since you read it, and never rewrite one whole from an earlier read, with a shell redirect or a script, or you erase what another of your turns wrote.",
@@ -10250,7 +10759,7 @@ var PLANNING = [
   "- A task is a plan of stages between open and done. Hold the current stage with claim_task and finish it with advance_task; the next stage becomes current, and past the last one the task is done.",
   "- Name stages by what gets done. Plan the next few steps rather than everything, and reshape with plan_task as the work teaches you.",
   "- Assign a stage to a role when anyone in it could do it, to a citizen only when it must be them, and to nobody when anyone in the project could. A citizen named on a stage must be a member of the task's project; add them first. A stage wakes everyone it is open to when it comes up, so the narrower the assignee, the fewer turns it costs.",
-  "- Reshape rather than force: another round is an inserted stage, and a wait on something outside the society is a stage named for what it waits on. When a check finds work unfinished, send the task back to an earlier stage with update_task.",
+  "- Reshape rather than force: another round is an inserted stage, and a wait on something outside the society is a stage named for what it waits on. When a check finds work unfinished, the holder of the current stage sends the task back to an earlier stage with update_task, and so may the user, the steward, and the concierge; anyone else asks the concierge in the task's thread.",
   "- A task that cannot start until other tasks finish names them with update_task blocked_by. While any of them is in play, its stage wakes nobody, neither when it comes up nor on a heartbeat; once the last has ended, done or abandoned, the stage wakes as if it had just come up, or wakes its holder. Nobody needs to clear the block or mention anyone when they end; change blocked_by only when the plan changes.",
   "- A gated stage is an independent check: nobody who held an earlier stage of the task may hold it, and only the user, the steward, and the concierge may add, remove, move, reassign, or ungate it. Ask them in the task's thread when a gate should change.",
   "- Commit your work on the task's branch before you advance, and say what you did in the advance note; it is the handover the next holder reads in the task's thread."
@@ -10288,7 +10797,7 @@ function renderOnboardingPreamble(context2) {
 function renderSkillsIndex(skills) {
   if (skills.length === 0) {
     return [
-      "None yet. Write the first one when you notice yourself doing something the same way twice."
+      "None yet. Something you have done the same way twice is a candidate for the first; the turn contract says when it is one."
     ];
   }
   return [
@@ -10304,7 +10813,7 @@ function renderInstructions(input) {
   if (norms.length > 0) {
     sections.push("", "## Society norms", "", norms);
   }
-  sections.push("", "## Core memory", "", memory.length === 0 ? "(empty)" : memory, "", "## Skills", "", ...renderSkillsIndex(input.skills ?? []), "", "## Where things are", "", `- Your home directory: ${input.homeDir}. memory/core.md is loaded every turn; memory/<topic>.md is your archive; skills/<name>/SKILL.md are your skills; projects/<slug>/notes.md are your notes. You may read and write all of it, and the board's search covers your archive and skills for you alone. The runner keeps it in git and shares it with the board after every turn, so whatever machine your next turn runs on has it; leave git there to the runner. Files over ${HOME_FILE_LIMIT_BYTES / (1024 * 1024)} MB are not kept.`, `- ${HOME_SCRATCH}/ in your home is your working folder in turns outside any project, and a thread's or a channel's conversation there works in a folder of its own inside it, which goes when the thread closes or the channel is archived: none of it is kept or shared, so put downloads, environments, and other working files there, and keep the rest of your home for what you mean to remember.`, `- The board projection: ${input.boardDir} (read-only markdown: society and project channels, tasks, threads; shared knowledge under projects/<slug>/knowledge/ and society/knowledge/; the society's skills under society/skills/; each project's dashboard, the status page the user reads on its view, at projects/<slug>/dashboard.md, which its members change with update_dashboard). Search it with your file tools; act through the board tools.`, "", "## Turn contract", "", TURN_CONTRACT, "", "## Planning", "", PLANNING, "", "## Governance", "", GOVERNANCE);
+  sections.push("", "## Core memory", "", memory.length === 0 ? "(empty)" : memory, "", "## Skills", "", ...renderSkillsIndex(input.skills ?? []), "", "## Where things are", "", `- Your home directory: ${input.homeDir}. memory/core.md is loaded every turn; memory/<topic>.md is your archive; skills/<name>/SKILL.md are your skills; projects/<slug>/notes.md are your notes. You may read and write all of it, and the board's search covers your archive and skills for you alone. The runner keeps it in git and shares it with the board after every turn, so whatever machine your next turn runs on has it; leave git there to the runner. Files over ${HOME_FILE_LIMIT_BYTES / (1024 * 1024)} MB are not kept.`, `- ${HOME_SCRATCH}/ in your home is your working folder in turns outside any project, and a thread's, a channel's, or a project's channels' conversation there works in a folder of its own inside it, which goes when the thread closes or the channel or the project is archived: none of it is kept or shared, so put downloads, environments, and other working files there, and keep the rest of your home for what you mean to remember.`, `- The board projection: ${input.boardDir} (read-only markdown: society and project channels, tasks, threads; shared knowledge under projects/<slug>/knowledge/ and society/knowledge/; the society's skills under society/skills/; each project's dashboard, the status page the user reads on its view, at projects/<slug>/dashboard.md, which its members change with update_dashboard). Search it with your file tools; act through the board tools.`, "", "## Turn contract", "", TURN_CONTRACT, "", "## Planning", "", PLANNING, "", "## Governance", "", GOVERNANCE);
   if (input.onboarding !== void 0) {
     sections.push("", "## First turn", "", renderOnboardingPreamble(input.onboarding));
   }
@@ -10317,9 +10826,9 @@ var REFLECTION_INTRO = "This turn is for your memory; take no new work, and answ
 var RECONCILE = "- Reconcile first: merge each copy listed under Edits to reconcile in your home into the file beside it, then delete the copy.";
 var REFLECTION_STEPS = [
   "- Consolidate memory/core.md: keep it to lessons that still hold, about sixty lines at most, and move detail worth keeping to memory/<topic>.md in your home, which the board's search covers for you alone.",
-  '- Extract a skill: a procedure you have followed twice goes to skills/<name>/SKILL.md, frontmatter with `name` and a one-line `description` and then the steps, with any script or reference it uses in the same folder. Propose it with kind "skill" when other citizens would use it.',
+  '- Extract a skill: a procedure you have followed twice is a candidate, and one that makes a citizen better at a kind of work on any project goes to skills/<name>/SKILL.md, frontmatter with `name` and a one-line `description` and then the steps, with any script or reference it uses in the same folder. Propose it with kind "skill" when more than one citizen would use it and nothing in it is tied to one place; one only you use stays yours.',
   "- Refresh profile.md: one paragraph on what you do well and what to send your way; the roster the front desk routes with is built from it.",
-  "- Share: a durable fact about this scope's codebase or process goes through write_knowledge; a norm the whole society should follow goes to the steward as a plain post in general.",
+  "- Share: how a codebase behaves goes in its AGENTS.md or README through a task like any change to the code, so propose it in that task's thread or the project channel; a durable fact about this scope as a place (runners, access, flow, where results live) goes through write_knowledge; a norm the whole society should follow goes to the steward as a plain post in general.",
   "- Report memoryUpdated: true in the status object when core.md or a skill changed."
 ];
 var MAX_BODY_CHARS = 1500;
@@ -10458,7 +10967,7 @@ function buildTurnPrompt(input) {
     lines.push("Operations signals arrived; they are listed under Operations signals below. Decide whether a proposal is warranted, and stay silent if not.");
   }
   if (dispatch.trigger.kind === "stage") {
-    lines.push("A stage is waiting for you: claim it with claim_task unless you hold it already, do the work in your worktree, which is on the task's branch, commit there, then advance_task. If the plan no longer fits, reshape it with plan_task.");
+    lines.push("A stage is waiting for you: claim it with claim_task unless you hold it already, do the work in your worktree, which is on the task's branch unless Your workspace says otherwise, commit there, then advance_task. If the plan no longer fits, reshape it with plan_task.");
   }
   if (dispatch.trigger.kind === "task_done") {
     lines.push("A task you created is done. Tell whoever asked for it, if anyone did.");
@@ -10477,8 +10986,11 @@ function buildTurnPrompt(input) {
   if (conversation === null && dispatch.channel !== void 0) {
     const ref = channelRef(dispatch.project === SOCIETY_SCOPE ? null : dispatch.project, dispatch.channel);
     lines.push(`This turn is in your conversation of ${ref}, a workstream with turns of its own: its posts, and the work it asks for. Your home conversation for ${dispatch.project} carries its general channel, and each other channel and each thread you take part in is a conversation of its own; read one when you need it, and leave its work to its turn. Post here with post_message and channel ${ref}.`);
+  } else if (conversation === null && dispatch.place !== void 0) {
+    lines.push(`This turn is in your conversation of project ${dispatch.place}'s channels, from outside the project: the posts in its general and its other channels that concern you, and the work they ask for. Your home conversation for ${dispatch.project} carries its general channel, and each other project's channels, each other channel, and each thread you take part in is a conversation of its own with turns of its own; read one when you need it, and leave its work to its turn. Answer in the channel a post came from with post_message.`);
   } else if (conversation === null) {
-    lines.push(`This turn is in your home conversation for ${dispatch.project}: its general channel, and work tied to no other channel and no thread. Each other channel, a workstream, and each thread you take part in, a task's, a proposal's, or a topic's, is a conversation of its own with turns of its own; read one when you need it, and leave its work to its turn.`);
+    const besides = dispatch.project === SOCIETY_SCOPE ? "Each other channel, each project's channels you are asked in from outside the project, and each thread you take part in, a task's, a proposal's, or a topic's," : "Each other channel, a workstream, and each thread you take part in, a task's, a proposal's, or a topic's,";
+    lines.push(`This turn is in your home conversation for ${dispatch.project}: its general channel, and work tied to no other channel and no thread. ${besides} is a conversation of its own with turns of its own; read one when you need it, and leave its work to its turn.`);
   } else {
     const { thread, task } = conversation;
     const about = thread.subject === void 0 ? "a topic" : `${thread.subject.kind} ${thread.subject.id}`;
@@ -10513,7 +11025,9 @@ function buildTurnPrompt(input) {
     lines.push("", "## The user stopped your previous turn", "", `It was ended on purpose at ${last.endedAt ?? "its end"}, not by a failure. Do not pick its work up again unless this turn asks for it. The worktree may hold uncommitted changes; run git status before doing anything else.`);
   }
   if (last !== null && (last.exitReason === "error" || last.exitReason === "timeout")) {
-    lines.push("", "## Your previous turn did not finish", "", `It ended with ${last.exitReason}${last.error === null ? "" : `: ${last.error}`}.`, "The worktree may hold uncommitted changes. Run git status before doing anything else.");
+    lines.push("", "## Your previous turn did not finish", "", `It ended with ${last.exitReason}${last.error === null ? "" : `: ${last.error}`}.`, ...last.sessionDropped === true ? [
+      "Its CLI could not resume this conversation's session, so the session was dropped and this turn starts a new one: nothing of your earlier turns here carries over but what is on the board and in your home."
+    ] : [], "The worktree may hold uncommitted changes. Run git status before doing anything else.");
   }
   const society = input.societyView;
   if (society !== void 0 && society !== null) {
@@ -10543,7 +11057,7 @@ function buildTurnPrompt(input) {
   if (knowledge !== void 0 && knowledge !== null) {
     lines.push("", `## Knowledge of ${dispatch.project}`, "");
     if (knowledge.topics.length === 0) {
-      lines.push("None yet. A durable fact about this scope's codebase or process is worth a write_knowledge call.");
+      lines.push("None yet. A durable fact about this place, such as its runners, access, flow, or where results live, is worth a write_knowledge call.");
     } else {
       lines.push(`Topics under ${knowledge.dir}; open one with your file tools when it is relevant.`, "");
       for (const topic of knowledge.topics) {
@@ -10609,6 +11123,13 @@ function capitalized(text) {
 }
 
 // packages/turn-host/dist/host.js
+function conversationOfJob(job) {
+  return {
+    ...job.thread === void 0 ? {} : { thread: job.thread },
+    ...job.channel === void 0 ? {} : { channel: job.channel },
+    ...job.place === void 0 ? {} : { place: job.place }
+  };
+}
 var SILENT = { info() {
 }, warn() {
 }, error() {
@@ -10619,6 +11140,12 @@ var DEFAULT_RESIDENT_IDLE_MS = 10 * 6e4;
 var LEASE_RENEW_MS = 10 * 6e4;
 var USER_POST_TRIGGER2 = "user_post";
 var OPS_TRIGGER2 = "ops_event";
+var RESUME_RETRIES = 3;
+function stuckNotice(stuck) {
+  const more = stuck.total - stuck.commits.length;
+  const commits = `${stuck.commits.map((commit) => `\`${commit}\``).join(", ")}${more > 0 ? `, and ${more} more` : ""}`;
+  return `${stuck.agent}'s worktree for this task holds commits that \`${stuck.branch}\` lacks and that the runner cannot fast-forward it to, because they no longer build on its tip or another worktree's commits build on it too: ${commits}. Until someone puts them on the branch, it lacks them, and so does what lands from it; any worktree of the project's clone can cherry-pick or merge them by id.`;
+}
 var MAX_SIGNALS = 30;
 var TurnHost = class {
   board;
@@ -10663,13 +11190,15 @@ var TurnHost = class {
     const actor = { name: agent.name, role: agent.role };
     const thread = dispatch.thread;
     const channel = thread === void 0 ? dispatch.channel : void 0;
-    const part = conversationPart({ thread: thread?.id, channel });
+    const place = thread === void 0 && channel === void 0 && dispatch.project === SOCIETY_SCOPE ? dispatch.place : void 0;
+    const part = conversationPart({ thread: thread?.id, channel, place });
     const startedAt = this.now().toISOString();
     const base = {
       agent: agent.name,
       project: dispatch.project,
       ...thread === void 0 ? {} : { thread: thread.id },
       ...channel === void 0 ? {} : { channel },
+      ...place === void 0 ? {} : { place },
       runner: runner.name,
       cli: agent.cli,
       session: null,
@@ -10694,23 +11223,25 @@ var TurnHost = class {
     const charter = await this.board.readRole(agent.role);
     const societyScope = dispatch.project === SOCIETY_SCOPE;
     const taskId = thread?.task === true ? thread.id : void 0;
+    const task = taskId === void 0 ? null : await this.board.findTask(taskId).then((found) => found.task).catch(() => null);
     const project = societyScope ? null : await this.board.readProject(dispatch.project);
-    const workspace = await this.workspaceOf(project, thread, channel);
+    const workspace = await this.workspaceOf(project, thread, channel, place, task);
     const sessions = await this.board.readSessions(agent.name, dispatch.project, part);
     const recorded = sessions.runner === runner.name ? sessions[agent.cli] : void 0;
     const newSession = recorded === void 0;
     const lastTurn = await this.board.readLastTurn(agent.name, dispatch.project, part);
     const costSoFarUsd = !newSession && lastTurn?.session === recorded ? lastTurn.sessionCostUsd ?? lastTurn.costUsd : 0;
+    const resumeRetries = !newSession && lastTurn?.session === recorded && lastTurn.resumeFailed === "retry" ? lastTurn.resumeRetries ?? 1 : 0;
     const digest = await this.board.readDigest({
       ...actor,
       scope: dispatch.project,
       ...thread === void 0 ? {} : { thread: thread.id },
-      ...channel === void 0 ? {} : { channel }
+      ...channel === void 0 ? {} : { channel },
+      ...place === void 0 ? {} : { place }
     }, { advance: false, limit: thread === void 0 ? 50 : 100 });
     const threadSoFar = thread !== void 0 && newSession ? (await this.board.listThread(thread.id).catch(() => [])).slice(-100) : null;
     const messages = threadSoFar ?? digest.messages;
     const cursorAfter = threadSoFar?.at(-1)?.id ?? digest.cursor;
-    const task = taskId === void 0 ? null : await this.board.findTask(taskId).then((found) => found.task).catch(() => null);
     const held = task === null ? [] : (await this.board.heldClaims(agent.name)).filter((each) => each.id === task.id);
     const onboarding = dispatch.onboarding || newSession && part === void 0 ? {
       agentName: agent.name,
@@ -10769,7 +11300,7 @@ var TurnHost = class {
       fresh: threadSoFar !== null,
       ...threadRecord.state === "closed" ? { replyIn: await this.replyIn(threadRecord) } : {}
     };
-    const ending = dispatch.trigger.kind === "closing" ? await this.endingOf(dispatch.project, threadRecord, task, channel) : null;
+    const ending = dispatch.trigger.kind === "closing" ? await this.endingOf(dispatch.project, threadRecord, task, channel, place) : null;
     const society = await this.board.society();
     const crons = [];
     for (const id of dispatch.crons ?? []) {
@@ -10818,6 +11349,7 @@ var TurnHost = class {
       scope: dispatch.project,
       ...thread === void 0 ? {} : { thread: thread.id },
       ...channel === void 0 ? {} : { channel },
+      ...place === void 0 ? {} : { place },
       session: recorded ?? null,
       costSoFarUsd,
       instructions,
@@ -10844,6 +11376,7 @@ var TurnHost = class {
       stopRequestedBy: null,
       held: held.map((each) => each.id),
       costSoFarUsd,
+      resumeRetries,
       configuredModel: agent.model ?? null,
       transcript: [],
       coldToken: residentKey === null ? token : null,
@@ -10857,6 +11390,7 @@ var TurnHost = class {
       project: dispatch.project,
       thread: thread?.id,
       channel,
+      place,
       runner: runner.name,
       session: recorded,
       newSession,
@@ -10893,8 +11427,7 @@ var TurnHost = class {
             turnId,
             agent: turn.job.agent,
             project: turn.job.scope,
-            thread: turn.job.thread,
-            channel: turn.job.channel,
+            ...conversationOfJob(turn.job),
             messages: sent.messages
           }).catch((error) => {
             this.log.warn({ turnId, error: String(error) }, "could not record a steer");
@@ -10902,17 +11435,14 @@ var TurnHost = class {
         }
       }
       turn.transcript.push(entry);
-      this.onEvent?.(turn.job.agent, turn.job.scope, entry.event, {
-        thread: turn.job.thread,
-        channel: turn.job.channel
-      });
+      this.onEvent?.(turn.job.agent, turn.job.scope, entry.event, conversationOfJob(turn.job));
     }
   }
   /** The turn in flight in a conversation, if any. */
   turnIn(agent, scope, conversation = {}) {
     for (const turn of this.open.values()) {
       const { job } = turn;
-      if (job.agent === agent && job.scope === scope && job.thread === conversation.thread && job.channel === conversation.channel) {
+      if (job.agent === agent && job.scope === scope && job.thread === conversation.thread && job.channel === conversation.channel && job.place === conversation.place) {
         return { turnId: job.turnId, runner: turn.runner, cli: job.cli };
       }
     }
@@ -10923,8 +11453,7 @@ var TurnHost = class {
     return [...this.open.values()].map(({ job }) => ({
       agent: job.agent,
       scope: job.scope,
-      ...job.thread === void 0 ? {} : { thread: job.thread },
-      ...job.channel === void 0 ? {} : { channel: job.channel }
+      ...conversationOfJob(job)
     }));
   }
   /** The turns in flight, for the interface: their conversations and where a mention reaches them. */
@@ -10933,8 +11462,7 @@ var TurnHost = class {
       turnId: turn.job.turnId,
       agent: turn.job.agent,
       scope: turn.job.scope,
-      ...turn.job.thread === void 0 ? {} : { thread: turn.job.thread },
-      ...turn.job.channel === void 0 ? {} : { channel: turn.job.channel },
+      ...conversationOfJob(turn.job),
       cli: turn.job.cli,
       ...turn.record.trigger.channel === void 0 ? {} : { askedIn: turn.record.trigger.channel },
       runner: turn.runner
@@ -10954,12 +11482,7 @@ var TurnHost = class {
       return "busy";
     }
     const { job } = turn;
-    const digest = await this.board.readDigest({
-      ...turn.actor,
-      scope: job.scope,
-      ...job.thread === void 0 ? {} : { thread: job.thread },
-      ...job.channel === void 0 ? {} : { channel: job.channel }
-    }, {
+    const digest = await this.board.readDigest({ ...turn.actor, scope: job.scope, ...conversationOfJob(job) }, {
       ...turn.delivered === null ? {} : { since_cursor: turn.delivered },
       advance: false,
       limit: 50
@@ -11019,6 +11542,8 @@ var TurnHost = class {
     }
     const { job } = turn;
     const part = conversationPart(job);
+    const resumeRetries = outcome.resumeFailed === "retry" ? turn.resumeRetries + 1 : void 0;
+    const dropSession = job.session !== null && (outcome.resumeFailed === "lost" || (resumeRetries ?? 0) >= RESUME_RETRIES);
     const finished = {
       ...turn.record,
       session: outcome.session,
@@ -11032,20 +11557,35 @@ var TurnHost = class {
       toolCalls: turn.transcript.filter((entry) => entry.event.type === "tool_call").length,
       model: outcome.model ?? turn.configuredModel,
       ...outcome.work === null ? {} : { work: outcome.work },
-      ...outcome.exitReason === "stopped" ? { stoppedBy: turn.stopRequestedBy ?? USER_NAME } : {}
+      ...outcome.exitReason === "stopped" ? { stoppedBy: turn.stopRequestedBy ?? USER_NAME } : {},
+      ...outcome.resumeFailed === void 0 ? {} : { resumeFailed: outcome.resumeFailed },
+      ...resumeRetries === void 0 ? {} : { resumeRetries },
+      ...dropSession ? { sessionDropped: true } : {}
     };
     const ended = await this.conversationEnded(job);
     const closing = turn.record.trigger.kind === "closing";
     const decided = closing && outcome.exitReason !== "error" && outcome.exitReason !== "timeout";
     const recorded = await this.recorded(turn, async () => {
-      if (outcome.session !== job.session) {
+      if (dropSession && job.session !== null) {
+        await this.board.dropSession(job.agent, job.scope, job.cli, job.session, part);
+        this.log.warn({
+          agent: job.agent,
+          project: job.scope,
+          thread: job.thread,
+          channel: job.channel,
+          place: job.place,
+          session: job.session,
+          resumeFailed: outcome.resumeFailed,
+          resumeRetries
+        }, "dropped a session its CLI could not resume");
+      } else if (outcome.session !== null && outcome.session !== job.session) {
         await this.board.writeSession(job.agent, job.scope, job.cli, outcome.session, turn.runner, part);
       }
       if (outcome.exitReason === "completed" || outcome.exitReason === "blocked" || outcome.exitReason === "stopped") {
         await this.board.setDigestCursor(job.agent, job.scope, turn.delivered, part);
         await this.renewLeases(turn.actor, turn.held);
         if (outcome.status?.needsUserDecision === true) {
-          await this.askUser(turn.actor, job, turn.record.startedAt, outcome.status.summary);
+          await this.askUser(turn.actor, job, turn.record.trigger.channel, turn.record.startedAt, outcome.status.summary);
         }
       }
       await this.board.finishTurn(finished, turn.transcript);
@@ -11057,7 +11597,7 @@ var TurnHost = class {
           conversation
         });
         if (!again) {
-          const where = conversation.kind === "thread" ? `thread ${conversation.id}` : `channel ${conversation.name}`;
+          const where = conversation.kind === "thread" ? `thread ${conversation.id}` : conversation.kind === "channel" ? `channel ${conversation.name}` : `project ${conversation.project}'s channels`;
           await this.board.publishSignal({
             kind: "stuck_workspace",
             key: `stuck_workspace:${job.agent}:${job.scope}:${conversationPart(job) ?? ""}`,
@@ -11074,12 +11614,18 @@ var TurnHost = class {
         this.log.warn({ runner: turn.runner, cli: job.cli, error: String(error) }, "could not record a quota");
       });
     }
+    for (const stuck of outcome.stuck ?? []) {
+      await this.board.postTaskNotice(stuck.branch.slice("task/".length), stuckNotice(stuck)).catch((error) => {
+        this.log.warn({ branch: stuck.branch, agent: stuck.agent, error: String(error) }, "could not tell a task's thread of commits its branch cannot take");
+      });
+    }
     if (recorded) {
       this.log.info({
         agent: job.agent,
         project: job.scope,
         thread: job.thread,
         channel: job.channel,
+        place: job.place,
         exitReason: finished.exitReason
       }, "turn finished");
       await this.takeSkillFiles(finished);
@@ -11146,6 +11692,7 @@ var TurnHost = class {
       project: dispatch.project,
       ...dispatch.thread === void 0 ? {} : { thread: dispatch.thread.id },
       ...dispatch.thread !== void 0 || dispatch.channel === void 0 ? {} : { channel: dispatch.channel },
+      ...dispatch.thread !== void 0 || dispatch.channel !== void 0 || dispatch.project !== SOCIETY_SCOPE || dispatch.place === void 0 ? {} : { place: dispatch.place },
       runner,
       cli: agent?.cli ?? null,
       session: null,
@@ -11192,24 +11739,26 @@ var TurnHost = class {
     return token;
   }
   /**
-   * Where a conversation works: a task's on its branch, any other thread's and a channel's in a
+   * Where a conversation works: a task's on its branch, which its stage's holder has to itself,
+   * any other thread's, a channel's, and a project's channels' seen from the society scope in a
    * place of its own, and the home in the citizen's own.
    */
-  async workspaceOf(project, thread, channel) {
+  async workspaceOf(project, thread, channel, place, task) {
     const own = thread !== void 0 ? thread.task ? {} : { thread: thread.id } : channel === void 0 ? {} : { channel };
     if (project === null) {
-      return { kind: "home", ...own };
+      return { kind: "home", ...own, ...place === void 0 ? {} : { place } };
     }
     const repo = projectRepo(project);
     if (thread?.task === true) {
-      return { kind: "task", repo, taskId: thread.id };
+      const holder = task?.status === "claimed" && task.claimedBy !== void 0 && task.claimedBy !== USER_NAME && (task.leaseExpiresAt === void 0 || new Date(task.leaseExpiresAt).getTime() > this.now().getTime()) ? task.claimedBy : void 0;
+      return { kind: "task", repo, taskId: thread.id, ...holder === void 0 ? {} : { holder } };
     }
-    const branches = (await this.board.listTasks(project.slug)).filter((task) => task.status === "open" || task.status === "claimed").map((task) => `task/${task.id}`);
+    const branches = (await this.board.listTasks(project.slug)).filter((each) => each.status === "open" || each.status === "claimed").map((each) => `task/${each.id}`);
     return { kind: "project", repo, branches, ...own };
   }
   /**
-   * Whether a thread conversation's task or thread has ended, or a channel conversation's channel
-   * was archived, which frees its workspace.
+   * Whether a thread conversation's task or thread has ended, a channel conversation's channel was
+   * archived, or a project conversation's project was, which frees its workspace.
    */
   async conversationEnded(job) {
     const conversation = workspaceConversationOf(job);
@@ -11223,14 +11772,14 @@ var TurnHost = class {
    * How a closing turn's conversation ended, and where its citizen asks someone else to take over
    * work that is not its own: the thread's channel while it is open, else the place's general.
    */
-  async endingOf(scope, thread, task, channel) {
+  async endingOf(scope, thread, task, channel, project) {
     const place = scope === SOCIETY_SCOPE ? null : scope;
     if (thread !== void 0) {
       const closed = `the thread "${thread.title}" on ${thread.channel} was closed${thread.closedBy === void 0 ? "" : ` by ${thread.closedBy}`}${task === null ? "" : `, its task ${task.status}`}`;
       return { how: closed, askIn: await this.replyIn(thread) };
     }
     if (channel === void 0) {
-      return null;
+      return project === void 0 ? null : { how: `project ${project} was archived`, askIn: channelRef(place, "general") };
     }
     const ref = channelRef(place, channel);
     const archived = (await this.board.listChannels()).find((each) => each.ref === ref)?.archived;
@@ -11244,13 +11793,15 @@ var TurnHost = class {
    * the user, which is what puts it before them. One that mentioned the user nowhere asks in its
    * own thread when it was in one that is still open, so the answer comes back to the same
    * conversation, and otherwise in a thread of its own on its conversation's channel, or its scope's
-   * general for the home, opened as the citizen with its summary. One that proposed something the
-   * user decides has put its decision before the user already, where deciding it clears it; a
-   * mention would stay until the user posted beside it.
+   * general for the home, opened as the citizen with its summary; a project's conversation in the
+   * society scope asks on the channel of the project its wake came from, else the project's general.
+   * One that proposed something the user decides has put its decision before the user already,
+   * where deciding it clears it; a mention would stay until the user posted beside it.
    */
-  async askUser(actor, job, since, summary) {
+  async askUser(actor, job, askedIn, since, summary) {
     const threadId = job.thread;
     const place = job.scope === SOCIETY_SCOPE ? null : job.scope;
+    const channel = job.place === void 0 ? channelRef(place, job.channel ?? "general") : askedIn !== void 0 && parseChannelRef(askedIn).project === job.place ? askedIn : channelRef(job.place, "general");
     try {
       if (await this.board.hasMentioned(actor.name, USER_NAME, since)) {
         return;
@@ -11268,7 +11819,7 @@ var TurnHost = class {
         return;
       }
       const thread = await this.board.openThread(actor, {
-        channel: channelRef(place, job.channel ?? "general"),
+        channel,
         title: `${actor.name} asks for a decision: ${summary}`.slice(0, 200)
       });
       await this.board.postMessage(actor, {
@@ -11319,6 +11870,12 @@ var DEFAULT_GRACE_MS = 2 * 6e4;
 var DEFAULT_REQUEST_TIMEOUT_MS = 10 * 6e4;
 var CONTROL_TIMEOUT_MS = 15e3;
 var FILE_TIMEOUT_MS = 6e4;
+var IMAGE_REFUSALS = {
+  missing: "NOT_FOUND",
+  outside: "FORBIDDEN",
+  not_image: "VALIDATION",
+  too_big: "VALIDATION"
+};
 var SWEEP_TIMEOUT_MS = 2 * 6e4;
 var DEFAULT_ACK_TIMEOUT_MS = 3e4;
 var RunnerHub = class {
@@ -11578,7 +12135,8 @@ var RunnerHub = class {
   async steer(conversation) {
     const turn = this.host.turnIn(conversation.agent, conversation.project, {
       thread: conversation.thread,
-      channel: conversation.channel
+      channel: conversation.channel,
+      place: conversation.place
     });
     const seat = turn === null ? void 0 : this.seats.get(turn.runner);
     if (turn === null || seat === void 0 || seat.send === null) {
@@ -11795,11 +12353,11 @@ var RunnerHub = class {
    * NOT_FOUND when the project has no runner yet or the branch or the path does not exist, and
    * `RunnerAwayError` while its runner is away.
    */
-  async readBranch(project, branch, path10) {
+  async readBranch(project, branch, path11) {
     const { seat, repo } = await this.projectSeat(project, "branchReads", "read files");
-    const file = BranchFileSchema.nullable().parse(await this.request(seat, (request) => ({ type: "file", request, read: { repo, branch, path: path10 } }), FILE_TIMEOUT_MS));
+    const file = BranchFileSchema.nullable().parse(await this.request(seat, (request) => ({ type: "file", request, read: { repo, branch, path: path11 } }), FILE_TIMEOUT_MS));
     if (file === null) {
-      throw new BoardError("NOT_FOUND", `${branch} has no ${path10 === "" ? "commit" : path10}`);
+      throw new BoardError("NOT_FOUND", `${branch} has no ${path11 === "" ? "commit" : path11}`);
     }
     return file;
   }
@@ -11819,14 +12377,41 @@ var RunnerHub = class {
    * What a branch of a project's repository did to one file since it left the default branch, read
    * on the runner the project lives on, with the same refusals as `branchChanges`.
    */
-  async branchDiff(project, branch, path10) {
+  async branchDiff(project, branch, path11) {
     const { seat, repo } = await this.projectSeat(project, "branchChanges", "list changes");
-    const diff = BranchFileDiffSchema.nullable().parse(await this.request(seat, (request) => ({ type: "diff", request, read: { repo, branch, path: path10 } }), FILE_TIMEOUT_MS));
+    const diff = BranchFileDiffSchema.nullable().parse(await this.request(seat, (request) => ({ type: "diff", request, read: { repo, branch, path: path11 } }), FILE_TIMEOUT_MS));
     if (diff === null) {
-      throw new BoardError("NOT_FOUND", `${branch} did not change ${path10}`);
+      throw new BoardError("NOT_FOUND", `${branch} did not change ${path11}`);
     }
     return diff;
   }
+  /**
+   * The image file a citizen's turn names for `upload_image`, read on the runner that turn runs on,
+   * which refuses a file outside the turn's worktree, its citizen's home, and the system temp
+   * folder, and anything but a PNG, JPEG, GIF, or WebP within the size limit; each refusal comes
+   * back as a `BoardError` in the runner's words.
+   */
+  async readTurnImage(actor, file) {
+    const turn = this.host.runningTurns().find((each) => each.agent === actor.name && each.scope === actor.scope && each.thread === actor.thread && each.channel === actor.channel && each.place === actor.place);
+    if (turn === void 0) {
+      throw new BoardError("INVALID_STATE", `${actor.name} has no turn running in this conversation to read ${file} from`);
+    }
+    const seat = this.seats.get(turn.runner);
+    if (seat === void 0 || seat.send === null) {
+      throw new RunnerAwayError(`runner ${turn.runner}, where the turn runs, is not connected`);
+    }
+    if (!seat.hello.imageReads) {
+      throw new BoardError("INVALID_STATE", `runner ${seat.name}, where the turn runs, cannot read images yet; upgrade it`);
+    }
+    const image = TurnImageSchema.nullable().parse(await this.request(seat, (request) => ({ type: "image", request, read: { turnId: turn.turnId, path: file } }), FILE_TIMEOUT_MS));
+    if (image === null) {
+      throw new BoardError("INVALID_STATE", `the turn is no longer running on runner ${seat.name}`);
+    }
+    if (image.kind === "refused") {
+      throw new BoardError(IMAGE_REFUSALS[image.why], image.detail);
+    }
+    return Buffer.from(image.content, "base64");
+  }
   /** The models a CLI offers, asked of a connected runner that has it; none when no runner has it. */
   /**
    * The connected runner a model list for `cli` comes from: the first of `prefer` that has the CLI,
@@ -12098,20 +12683,20 @@ async function handleMcpRequest(board2, actor, request, version) {
 import { Hono as Hono3 } from "hono";
 import { compress } from "hono/compress";
 import { streamSSE as streamSSE2 } from "hono/streaming";
-import { z as z18, ZodError } from "zod";
+import { z as z19, ZodError } from "zod";
 
 // apps/server/dist/github-auth.js
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { Hono } from "hono";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var SIGN_IN_TTL_MS = 30 * 24 * 36e5;
 var STATE_TTL_MS = 10 * 6e4;
 var MAX_STATES = 1e3;
-var TokenAnswerSchema = z17.object({ access_token: z17.string().min(1) });
-var GithubUserSchema = z17.object({
-  login: z17.string().min(1),
-  id: z17.number().int(),
-  avatar_url: z17.string().optional()
+var TokenAnswerSchema = z18.object({ access_token: z18.string().min(1) });
+var GithubUserSchema = z18.object({
+  login: z18.string().min(1),
+  id: z18.number().int(),
+  avatar_url: z18.string().optional()
 });
 function githubAvatar(url) {
   try {
@@ -12307,7 +12892,7 @@ function rateLimit(options) {
 }
 
 // apps/server/dist/runner-routes.js
-import path7 from "node:path";
+import path8 from "node:path";
 import { Hono as Hono2 } from "hono";
 import { streamSSE } from "hono/streaming";
 
@@ -12500,7 +13085,7 @@ function runnerRoutes(board2, hub, enrollments, enrollLimit) {
     const marker = `/homes/${agent}/git`;
     const at = c.req.path.indexOf(marker);
     return homeGit.serve({
-      root: path7.dirname(repository),
+      root: path8.dirname(repository),
       agent,
       rest: at === -1 ? "" : c.req.path.slice(at + marker.length),
       request: c.req.raw,
@@ -12513,7 +13098,7 @@ function runnerRoutes(board2, hub, enrollments, enrollLimit) {
 
 // apps/server/dist/static.js
 import { readFile as readFile5, stat as stat4 } from "node:fs/promises";
-import path8 from "node:path";
+import path9 from "node:path";
 var CONTENT_TYPES = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
@@ -12541,11 +13126,11 @@ function within2(root, pathname) {
   } catch {
     return null;
   }
-  const candidate = path8.resolve(root, `.${decoded}`);
-  return candidate === root || candidate.startsWith(root + path8.sep) ? candidate : null;
+  const candidate = path9.resolve(root, `.${decoded}`);
+  return candidate === root || candidate.startsWith(root + path9.sep) ? candidate : null;
 }
 function spaHandler(staticDir) {
-  const root = path8.resolve(staticDir);
+  const root = path9.resolve(staticDir);
   return async (c) => {
     const { pathname } = new URL(c.req.url);
     if (pathname.startsWith("/api/")) {
@@ -12556,14 +13141,14 @@ function spaHandler(staticDir) {
     if (file !== null && await isFile(file)) {
       return c.body(await readFile5(file), 200, {
         ...headers,
-        "content-type": CONTENT_TYPES[path8.extname(file)] ?? "application/octet-stream",
+        "content-type": CONTENT_TYPES[path9.extname(file)] ?? "application/octet-stream",
         "cache-control": pathname.startsWith("/assets/") ? "public, max-age=31536000, immutable" : "no-cache"
       });
     }
     if (pathname.startsWith("/assets/")) {
       return c.text("not found", 404, headers);
     }
-    const index = path8.join(root, "index.html");
+    const index = path9.join(root, "index.html");
     if (!await isFile(index)) {
       return c.text("The interface is not built: run pnpm build:web.", 404);
     }
@@ -12586,19 +13171,19 @@ var ERROR_STATUS = {
   INVALID_STATE: 409
 };
 var EVENT_PAGE = 100;
-var RetireBodySchema = z18.object({ reason: z18.string().min(1) });
-var RunnerBodySchema = z18.object({ name: NameSchema });
-var EnrollmentApprovalSchema = z18.object({ name: NameSchema });
-var HomeRunnerBodySchema = z18.object({ runner: NameSchema.nullable() });
-var ModelBodySchema = z18.object({ model: ModelNameSchema.nullable() });
-var EffortBodySchema = z18.object({ effort: EffortSchema.nullable() });
-var HistoryLimitSchema = z18.coerce.number().int().min(1).max(500);
-var MessageIdsSchema = z18.string().transform((ids) => ids.split(",").filter((id) => id !== "")).pipe(z18.array(UlidSchema).min(1).max(MESSAGE_LOOKUP_LIMIT));
-var TimezoneBodySchema = z18.object({ timezone: TimeZoneSchema });
-var ChannelBodySchema = z18.object({
+var RetireBodySchema = z19.object({ reason: z19.string().min(1) });
+var RunnerBodySchema = z19.object({ name: NameSchema });
+var EnrollmentApprovalSchema = z19.object({ name: NameSchema });
+var HomeRunnerBodySchema = z19.object({ runner: NameSchema.nullable() });
+var ModelBodySchema = z19.object({ model: ModelNameSchema.nullable() });
+var EffortBodySchema = z19.object({ effort: EffortSchema.nullable() });
+var HistoryLimitSchema = z19.coerce.number().int().min(1).max(500);
+var MessageIdsSchema = z19.string().transform((ids) => ids.split(",").filter((id) => id !== "")).pipe(z19.array(UlidSchema).min(1).max(MESSAGE_LOOKUP_LIMIT));
+var TimezoneBodySchema = z19.object({ timezone: TimeZoneSchema });
+var ChannelBodySchema = z19.object({
   project: NameSchema.nullable().default(null),
   name: NameSchema,
-  purpose: z18.string().min(1)
+  purpose: z19.string().min(1)
 });
 function bearer2(c) {
   const header = c.req.header("authorization") ?? "";
@@ -12729,6 +13314,7 @@ function createApp(deps) {
   });
   api.get("/society/knowledge", async (c) => c.json(await board2.listKnowledge(null)));
   api.get("/skills", async (c) => c.json(await board2.listSocietySkills()));
+  api.get("/skills/:name/files", async (c) => c.json(await board2.readSocietySkillFiles(NameSchema.parse(c.req.param("name")))));
   api.post("/agents/:name/retire", async (c) => {
     const body = RetireBodySchema.parse(await c.req.json());
     const { tokenHash: _hash, ...agent } = await board2.retireAgent(c.get("actor"), {
@@ -12770,7 +13356,7 @@ function createApp(deps) {
   });
   api.put("/roles/:name", async (c) => {
     const charter = RoleCharterSchema.parse({
-      ...z18.record(z18.string(), z18.unknown()).parse(await c.req.json()),
+      ...z19.record(z19.string(), z19.unknown()).parse(await c.req.json()),
       name: c.req.param("name")
     });
     return c.json(await board2.setRoleCharter(c.get("actor"), charter));
@@ -12809,6 +13395,15 @@ function createApp(deps) {
     return c.json(await deps.runners.branchDiff(task.project, `task/${task.id}`, BranchPathSchema.parse(c.req.param("path"))));
   });
   api.get("/tasks/:id/files/:path{.+}", (c) => taskFile(c, c.req.param("path")));
+  api.get("/images/:id", async (c) => {
+    const { type, bytes } = await board2.readImage(UlidSchema.parse(c.req.param("id")));
+    return c.body(new Uint8Array(bytes), 200, {
+      "content-type": IMAGE_MEDIA_TYPES[type],
+      "cache-control": "private, max-age=31536000, immutable",
+      "x-content-type-options": "nosniff",
+      "content-security-policy": "default-src 'none'; sandbox"
+    });
+  });
   api.get("/threads", async (c) => c.json(await board2.listThreads()));
   api.get("/requests", async (c) => c.json(await board2.listRequests()));
   api.get("/threads/:id", async (c) => {
@@ -13163,7 +13758,10 @@ var TurnHub = class {
   get lastSeq() {
     return this.seq;
   }
-  /** Records one event of a turn, in its scope and its conversation there: a thread's, a channel's, or home. */
+  /**
+   * Records one event of a turn, in its scope and its conversation there: a thread's, a channel's,
+   * a project's channels' in the society scope, or home.
+   */
   push(agent, project, event, conversation = {}) {
     this.seq += 1;
     const item = {
@@ -13173,6 +13771,7 @@ var TurnHub = class {
       project,
       ...conversation.thread === void 0 ? {} : { thread: conversation.thread },
       ...conversation.channel === void 0 ? {} : { channel: conversation.channel },
+      ...conversation.place === void 0 ? {} : { place: conversation.place },
       event
     };
     this.buffer.push(item);
@@ -13231,6 +13830,7 @@ var host = new TurnHost({
 });
 var runners = new RunnerHub({ board, host, version: VERSION, log });
 board.watchTurns(() => host.inFlight());
+board.readImagesWith((actor, file) => runners.readTurnImage(actor, file));
 var concurrency = config.concurrency ?? Number.POSITIVE_INFINITY;
 var timings = parseTimings(JSON.parse(process.env["STELLARIS_TIMINGS"] ?? "{}"));
 var scheduler = new Scheduler({ board, runner: runners, log, concurrency, timings });
@@ -13248,8 +13848,8 @@ var view = {
     return scheduler.activeSignals;
   }
 };
-var webDir = process.env["STELLARIS_WEB_DIR"] ?? path9.resolve(import.meta.dirname, "../../web/dist");
-var webBuilt = await access2(path9.join(webDir, "index.html")).then(() => true, () => false);
+var webDir = process.env["STELLARIS_WEB_DIR"] ?? path10.resolve(import.meta.dirname, "../../web/dist");
+var webBuilt = await access2(path10.join(webDir, "index.html")).then(() => true, () => false);
 var app = createApp({
   board,
   version: VERSION,