@kubitnodes/stellaris 0.3.22 → 0.3.23

package/dist/server/index.js

@@ -9,7 +9,7 @@ import { serve } from "@hono/node-server";
 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 { 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",
@@ -1037,130 +1039,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 +1226,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 +1238,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 +1254,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 +1276,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 +1345,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 +1370,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 +1385,50 @@ var TurnExitReasonSchema = z7.enum([
   "blocked",
   "stopped"
 ]);
-var AgentEventSchema = z7.discriminatedUnion("type", [
-  z7.object({
-    type: z7.literal("turn_started"),
+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,
@@ -1387,10 +1440,10 @@ var LiveTurnEventSchema = z7.object({
 });
 
 // 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 +1454,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,29 +1534,29 @@ 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()
   }),
-  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 })
 ]);
-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. */
@@ -1512,130 +1567,130 @@ var TurnJobSchema = z8.object({
    * 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 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(),
+  sessionCostUsd: z9.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),
+  session: z9.string().min(1),
   /** 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),
   /**
    * 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,9 +1704,23 @@ 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 })
 ]);
 function workspaceConversationOf(turn) {
   if (turn.thread !== void 0) {
@@ -1659,65 +1728,70 @@ function workspaceConversationOf(turn) {
   }
   return turn.channel === void 0 ? null : { kind: "channel", scope: turn.scope, name: turn.channel };
 }
-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 +1800,7 @@ function isSafeRelativePath(file) {
 }
 
 // packages/shared/dist/turns.js
-var TriggerKindSchema = z9.enum([
+var TriggerKindSchema = z10.enum([
   "mention",
   "stage",
   "task_done",
@@ -1740,11 +1814,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,17 +1826,17 @@ 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(),
   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}`);
@@ -1786,7 +1860,7 @@ 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({
+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,
@@ -1797,31 +1871,31 @@ var TurnRecordSchema = z9.object({
   channel: 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(),
   /** 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,
@@ -1829,49 +1903,49 @@ var RunningTurnSchema = z9.object({
   channel: 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(),
+  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 +1961,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 +1971,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 +1987,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 +1999,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 +2009,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 +2022,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 +2056,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 +2160,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.23";
 
 // packages/shared/dist/mentions.js
 import { parse, postprocess, preprocess } from "micromark";
@@ -2825,32 +2899,32 @@ 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(),
+  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);
@@ -3140,19 +3214,19 @@ 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),
+  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) {
@@ -3398,6 +3472,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");
   }
@@ -3433,27 +3514,27 @@ 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({}),
   /** 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: {} };
 function conversationKey(scope, part) {
@@ -3492,7 +3573,7 @@ function byId(a, b) {
 function turnTime(record) {
   return record.endedAt ?? record.startedAt;
 }
-var PausedSchema = z15.object({ paused: z15.boolean() });
+var PausedSchema = z16.object({ paused: z16.boolean() });
 var DEFAULT_LEASE_MS = 30 * 60 * 1e3;
 function withoutMentions(text) {
   return text.replaceAll(MENTION_PATTERN, "$1$2");
@@ -3517,7 +3598,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";
@@ -3531,10 +3612,11 @@ var CHANNEL_CONVERSATIONS = "channel-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.";
@@ -3666,6 +3748,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();
@@ -3730,7 +3813,8 @@ var Board = class _Board {
       CHANNEL_CONVERSATIONS,
       DASHBOARD_UPDATES,
       CRON_VERBS,
-      KNOWLEDGE_NOTICES
+      KNOWLEDGE_NOTICES,
+      IMAGE_UPLOADS
     ].filter((name) => !applied.includes(name));
     if (pending.length === 0) {
       return;
@@ -3760,13 +3844,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 +3859,9 @@ var Board = class _Board {
     if (pending.includes(KNOWLEDGE_NOTICES)) {
       await this.noticeKnowledgeNotes();
     }
+    if (pending.includes(IMAGE_UPLOADS)) {
+      await this.grantBeside("post_message", "upload_image");
+    }
     await writeJson(file, { applied: [...applied, ...pending] });
   }
   /**
@@ -3816,12 +3903,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 +4066,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(path6.join(this.paths.tasks(slug), file), z16.record(z16.string(), z16.unknown()));
         const legacy = raw.data["thread"];
         if (legacy === void 0) {
           continue;
@@ -4057,7 +4144,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 +4190,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));
@@ -4420,7 +4507,7 @@ ${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) {
@@ -4440,7 +4527,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 {
@@ -5403,6 +5490,60 @@ ${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 = path6.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 = [];
@@ -5794,6 +5935,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
@@ -6623,6 +6771,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 +6819,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. */
   /**
@@ -7077,7 +7227,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 {
@@ -7351,7 +7501,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 +7518,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}
 `);
@@ -8584,7 +8734,7 @@ 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 {};
@@ -8611,21 +8761,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 +8787,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;
@@ -10237,9 +10387,9 @@ var TURN_CONTRACT = [
   "- 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 +10400,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 +10438,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 [
@@ -10317,9 +10467,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;
@@ -10543,7 +10693,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) {
@@ -11319,6 +11469,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 {
@@ -11827,6 +11983,33 @@ var RunnerHub = class {
     }
     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);
+    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 +12281,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 {
@@ -12586,19 +12769,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") ?? "";
@@ -12770,7 +12953,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 +12992,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) => {
@@ -13231,6 +13423,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 });