@kubitnodes/stellaris 0.3.22 → 0.3.23

package/dist/cli/index.js

@@ -9,7 +9,7 @@ import { Command } from "commander";
 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",
@@ -985,130 +987,169 @@ var DecisionSchema = z5.object({
 });
 
 // packages/shared/dist/verbs.js
+import { z as z7 } from "zod";
+
+// packages/shared/dist/images.js
 import { z as z6 } from "zod";
-var MomentSchema = z6.iso.datetime({ offset: true });
-var CronTitleSchema = z6.string().trim().min(1).max(120);
-var CronNoteSchema = z6.string().trim().min(1).max(4e3);
+var IMAGE_LIMIT_BYTES = 8 * 1024 * 1024;
+var ImageTypeSchema = z6.enum(["png", "jpeg", "gif", "webp"]);
+function startsWith(bytes, prefix, at = 0) {
+  for (let index = 0; index < prefix.length; index += 1) {
+    if (bytes[at + index] !== prefix[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+var ascii = (text) => new TextEncoder().encode(text);
+function imageTypeOf(bytes) {
+  if (startsWith(bytes, [137, 80, 78, 71, 13, 10, 26, 10])) {
+    return "png";
+  }
+  if (startsWith(bytes, [255, 216, 255])) {
+    return "jpeg";
+  }
+  if (startsWith(bytes, ascii("GIF87a")) || startsWith(bytes, ascii("GIF89a"))) {
+    return "gif";
+  }
+  if (startsWith(bytes, ascii("RIFF")) && startsWith(bytes, ascii("WEBP"), 8)) {
+    return "webp";
+  }
+  return null;
+}
+var ImagePathSchema = z6.string().min(1).max(4096).refine((value) => !value.includes("\0"), { message: "a path with no NUL character" });
+var IMAGE_SCHEME = "image:";
+var UploadedImageSchema = z6.object({
+  id: UlidSchema,
+  type: ImageTypeSchema,
+  size: z6.number().int().positive(),
+  markdown: z6.string()
+});
+
+// packages/shared/dist/verbs.js
+var MomentSchema = z7.iso.datetime({ offset: true });
+var CronTitleSchema = z7.string().trim().min(1).max(120);
+var CronNoteSchema = z7.string().trim().min(1).max(4e3);
 var VerbInputs = {
-  post_message: z6.object({
+  post_message: z7.object({
     /** Required outside a thread; in one it may be left out, and must otherwise be the thread's. */
     channel: ChannelRefSchema.optional(),
-    body: z6.string().min(1),
+    body: z7.string().min(1),
     thread_id: UlidSchema.optional()
   }),
-  read_inbox: z6.object({
+  read_inbox: z7.object({
     since_cursor: UlidSchema.nullable().optional(),
-    limit: z6.number().int().positive().max(200).default(50),
-    advance: z6.boolean().default(true)
+    limit: z7.number().int().positive().max(200).default(50),
+    advance: z7.boolean().default(true)
   }),
-  search: z6.object({
-    query: z6.string().min(1),
+  search: z7.object({
+    query: z7.string().min(1),
     project: NameSchema.optional(),
     channel: ChannelRefSchema.optional(),
-    limit: z6.number().int().positive().max(100).default(20)
+    limit: z7.number().int().positive().max(100).default(20)
   }),
   /** On a task or a proposal, whose id the thread takes, or on a channel with a title. */
-  open_thread: z6.object({
+  open_thread: z7.object({
     task_id: UlidSchema.optional(),
     proposal_id: UlidSchema.optional(),
     channel: ChannelRefSchema.optional(),
-    title: z6.string().min(1).max(200).optional()
+    title: z7.string().min(1).max(200).optional()
   }),
-  close_thread: z6.object({ thread_id: UlidSchema, summary: z6.string().min(1) }),
-  create_task: z6.object({
+  close_thread: z7.object({ thread_id: UlidSchema, summary: z7.string().min(1) }),
+  create_task: z7.object({
     project: NameSchema,
-    title: z6.string().min(1).max(200),
-    body: z6.string().default(""),
+    title: z7.string().min(1).max(200),
+    body: z7.string().default(""),
     parent_id: UlidSchema.optional(),
-    required_capabilities: z6.array(z6.string()).default([]),
+    required_capabilities: z7.array(z7.string()).default([]),
     /** The plan; without it the task gets one stage, work, that anyone in the project may take. */
-    stages: z6.array(PlanStageSchema).min(1).optional(),
+    stages: z7.array(PlanStageSchema).min(1).optional(),
     /** A channel of the project the task belongs to, such as a release's; its thread opens there. */
     channel: NameSchema.default("general")
   }),
-  claim_task: z6.object({ task_id: UlidSchema }),
-  release_task: z6.object({ task_id: UlidSchema }),
-  update_task: z6.object({
+  claim_task: z7.object({ task_id: UlidSchema }),
+  release_task: z7.object({ task_id: UlidSchema }),
+  update_task: z7.object({
     task_id: UlidSchema,
     /** Move the task back to this earlier stage. */
     stage: StageIdSchema.optional(),
-    status: z6.enum(["abandoned"]).optional(),
+    status: z7.enum(["abandoned"]).optional(),
     /** Posted to the task's thread as the caller, marked with the step when the task moved. */
-    note: z6.string().min(1).optional(),
-    blocked_by: z6.array(UlidSchema).optional(),
+    note: z7.string().min(1).optional(),
+    blocked_by: z7.array(UlidSchema).optional(),
     /**
      * The pull request a `ghpr` task lands through, on its project's repository, with the merge
      * commit's subject and body; null unlinks it.
      */
-    pull_request: z6.object({
+    pull_request: z7.object({
       url: PullRequestUrlSchema,
       merge_subject: MergeSubjectSchema.optional(),
-      merge_body: z6.string().max(2e4).optional()
+      merge_body: z7.string().max(2e4).optional()
     }).nullable().optional()
   }),
-  get_task: z6.object({ task_id: UlidSchema }),
-  subscribe: z6.object({ channel: ChannelRefSchema }),
-  unsubscribe: z6.object({ channel: ChannelRefSchema }),
-  propose: z6.object({
+  get_task: z7.object({ task_id: UlidSchema }),
+  subscribe: z7.object({ channel: ChannelRefSchema }),
+  unsubscribe: z7.object({ channel: ChannelRefSchema }),
+  propose: z7.object({
     kind: ProposalKindSchema,
-    charter: z6.record(z6.string(), z6.unknown()),
-    rationale: z6.string().default("")
+    charter: z7.record(z7.string(), z7.unknown()),
+    rationale: z7.string().default("")
   }),
-  approve: z6.object({ proposal_id: UlidSchema, reason: z6.string().optional() }),
-  reject: z6.object({ proposal_id: UlidSchema, reason: z6.string().min(1) }),
-  create_project: z6.object({
+  approve: z7.object({ proposal_id: UlidSchema, reason: z7.string().optional() }),
+  reject: z7.object({ proposal_id: UlidSchema, reason: z7.string().min(1) }),
+  create_project: z7.object({
     slug: NameSchema,
-    name: z6.string().min(1).optional(),
-    repo: z6.string().min(1).nullable().default(null),
+    name: z7.string().min(1).optional(),
+    repo: z7.string().min(1).nullable().default(null),
     default_branch: DefaultBranchSchema.default("main"),
     on_done: CompletionEffectSchema.optional()
   }),
-  join_project: z6.object({ project: NameSchema, agent: NameSchema.optional() }),
-  leave_project: z6.object({ project: NameSchema, agent: NameSchema.optional() }),
-  write_knowledge: z6.object({
+  join_project: z7.object({ project: NameSchema, agent: NameSchema.optional() }),
+  leave_project: z7.object({ project: NameSchema, agent: NameSchema.optional() }),
+  write_knowledge: z7.object({
     /** A project you belong to, or null for society knowledge, which the steward and the user curate. */
     project: NameSchema.nullable().default(null),
     topic: NameSchema,
-    body: z6.string().min(1),
+    body: z7.string().min(1),
     /** The `revision` in the frontmatter of the topic you read, 0 when it names none or for a new topic. */
-    revision: z6.number().int().min(0)
+    revision: z7.number().int().min(0)
   }),
-  remove_knowledge: z6.object({
+  remove_knowledge: z7.object({
     /** As for write_knowledge: a project you belong to, or null for society knowledge. */
     project: NameSchema.nullable().default(null),
     topic: NameSchema
   }),
-  plan_task: z6.object({
+  plan_task: z7.object({
     task_id: UlidSchema,
-    stages: z6.array(PlanEditStageSchema),
+    stages: z7.array(PlanEditStageSchema),
     on_done: CompletionEffectSchema.optional()
   }),
   /** The note is posted to the task's thread as the caller, marked with the step. */
-  advance_task: z6.object({ task_id: UlidSchema, note: z6.string().min(1).optional() }),
-  configure_project: z6.object({
+  advance_task: z7.object({ task_id: UlidSchema, note: z7.string().min(1).optional() }),
+  configure_project: z7.object({
     project: NameSchema,
     on_done: CompletionEffectSchema.optional(),
     /** A new display name; the slug, which everything refers to the project by, never changes. */
-    name: z6.string().trim().min(1).max(120).optional(),
+    name: z7.string().trim().min(1).max(120).optional(),
     /** The branch tasks start from and land on from now; tasks in play keep their branches. */
     default_branch: DefaultBranchSchema.optional()
   }),
-  archive_project: z6.object({ project: NameSchema, reason: z6.string().min(1) }),
-  create_channel: z6.object({
+  archive_project: z7.object({ project: NameSchema, reason: z7.string().min(1) }),
+  create_channel: z7.object({
     /** A project, or null for a channel of the society. */
     project: NameSchema.nullable().default(null),
     name: NameSchema,
-    purpose: z6.string().min(1)
+    purpose: z7.string().min(1)
   }),
-  archive_channel: z6.object({ channel: ChannelRefSchema, reason: z6.string().min(1) }),
-  update_dashboard: z6.object({
+  archive_channel: z7.object({ channel: ChannelRefSchema, reason: z7.string().min(1) }),
+  update_dashboard: z7.object({
     project: NameSchema,
     /** The whole dashboard as markdown; the board keeps its frontmatter. */
-    body: z6.string().min(1),
+    body: z7.string().min(1),
     /** The `revision` in the frontmatter of the dashboard you read, 0 when it names none. */
-    revision: z6.number().int().min(0)
+    revision: z7.number().int().min(0)
   }),
-  create_cron: z6.object({
+  create_cron: z7.object({
     title: CronTitleSchema,
     /** What to do when it fires; quoted in the prompt of every turn it starts. */
     note: CronNoteSchema,
@@ -1127,10 +1168,10 @@ var VerbInputs = {
     /** An open channel of that place other than general, whose conversation it fires in. */
     channel: NameSchema.optional()
   }),
-  update_cron: z6.object({
+  update_cron: z7.object({
     cron_id: UlidSchema,
     /** Pause it, or resume it, which starts its schedule afresh from now. */
-    paused: z6.boolean().optional(),
+    paused: z7.boolean().optional(),
     title: CronTitleSchema.optional(),
     note: CronNoteSchema.optional(),
     /** A new expression, or `at` for one time; either starts the schedule afresh. */
@@ -1139,12 +1180,16 @@ var VerbInputs = {
     timezone: TimeZoneSchema.nullable().optional(),
     at: MomentSchema.optional()
   }),
-  remove_cron: z6.object({ cron_id: UlidSchema, reason: z6.string().trim().min(1) }),
-  remove_skill: z6.object({ name: NameSchema, reason: z6.string().trim().min(1) })
+  remove_cron: z7.object({ cron_id: UlidSchema, reason: z7.string().trim().min(1) }),
+  remove_skill: z7.object({ name: NameSchema, reason: z7.string().trim().min(1) }),
+  upload_image: z7.object({
+    /** The image file on the machine your turn runs on: absolute, or relative to your working directory. */
+    path: ImagePathSchema
+  })
 };
 
 // packages/shared/dist/events.js
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var BOARD_EVENT_TYPES = [
   "society.initialized",
   "project.added",
@@ -1208,21 +1253,22 @@ var BOARD_EVENT_TYPES = [
   "cron.updated",
   "cron.fired",
   "cron.skipped",
-  "cron.ended"
+  "cron.ended",
+  "image.uploaded"
 ];
-var BoardEventTypeSchema = z7.enum(BOARD_EVENT_TYPES);
-var BoardEventSchema = z7.object({
+var BoardEventTypeSchema = z8.enum(BOARD_EVENT_TYPES);
+var BoardEventSchema = z8.object({
   id: UlidSchema,
   ts: IsoDateTimeSchema,
   type: BoardEventTypeSchema,
   actor: NameSchema,
-  payload: z7.record(z7.string(), z7.unknown())
+  payload: z8.record(z8.string(), z8.unknown())
 });
-var UsageSchema = z7.object({
-  inputTokens: z7.number().int().nonnegative(),
-  outputTokens: z7.number().int().nonnegative(),
-  cacheReadTokens: z7.number().int().nonnegative().default(0),
-  cacheWriteTokens: z7.number().int().nonnegative().default(0)
+var UsageSchema = z8.object({
+  inputTokens: z8.number().int().nonnegative(),
+  outputTokens: z8.number().int().nonnegative(),
+  cacheReadTokens: z8.number().int().nonnegative().default(0),
+  cacheWriteTokens: z8.number().int().nonnegative().default(0)
 });
 function addUsage(a, b) {
   return {
@@ -1232,14 +1278,14 @@ function addUsage(a, b) {
     cacheWriteTokens: a.cacheWriteTokens + b.cacheWriteTokens
   };
 }
-var TurnStatusSchema = z7.object({
-  summary: z7.string().min(1),
-  claimsHeld: z7.array(UlidSchema).default([]),
-  blockedOn: z7.array(z7.string()).default([]),
-  needsUserDecision: z7.boolean().default(false),
-  memoryUpdated: z7.boolean().default(false)
-});
-var TurnExitReasonSchema = z7.enum([
+var TurnStatusSchema = z8.object({
+  summary: z8.string().min(1),
+  claimsHeld: z8.array(UlidSchema).default([]),
+  blockedOn: z8.array(z8.string()).default([]),
+  needsUserDecision: z8.boolean().default(false),
+  memoryUpdated: z8.boolean().default(false)
+});
+var TurnExitReasonSchema = z8.enum([
   "completed",
   "timeout",
   "error",
@@ -1247,50 +1293,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,
@@ -1302,105 +1348,107 @@ 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 HOME_SCRATCH = "scratch";
 var HOME_FILE_LIMIT_BYTES = 8 * 1024 * 1024;
-var RunnerHelloSchema = z8.object({
-  protocol: z8.number().int().positive(),
-  version: z8.string().min(1),
+var RunnerHelloSchema = z9.object({
+  protocol: z9.number().int().positive(),
+  version: z9.string().min(1),
   os: RunnerOsSchema,
-  clis: z8.array(CliKindSchema),
+  clis: z9.array(CliKindSchema),
   /** The CLIs whose adapter can keep a session warm between turns. */
-  residentClis: z8.array(CliKindSchema).default([]),
+  residentClis: z9.array(CliKindSchema).default([]),
   /** The CLIs whose adapter can take input into a running turn; the server steers only these. */
-  steerableClis: z8.array(CliKindSchema).default([]),
+  steerableClis: z9.array(CliKindSchema).default([]),
   /** The CLIs whose adapter can stop a running turn; the server stops only these. */
-  stoppableClis: z8.array(CliKindSchema).default([]),
+  stoppableClis: z9.array(CliKindSchema).default([]),
   /** Whether the runner answers file reads on its projects' branches; one from before never does. */
-  branchReads: z8.boolean().default(false),
+  branchReads: z9.boolean().default(false),
   /** Whether the runner lists what a branch changed; one from before never does. */
-  branchChanges: z8.boolean().default(false),
+  branchChanges: z9.boolean().default(false),
   /** Whether the runner answers a read of a CLI's quota; one from before never does. */
-  quotaReads: z8.boolean().default(false),
-  capabilities: z8.array(z8.string()).default([]),
+  quotaReads: z9.boolean().default(false),
+  /** Whether the runner reads an image a turn running there uploads; one from before never does. */
+  imageReads: z9.boolean().default(false),
+  capabilities: z9.array(z9.string()).default([]),
   /**
    * What the runner's account lacks of the git identity citizens' own commits carry, checked
    * before each hello outside any repository; empty when it has both. Absent from a runner from
    * before the check, which no default fills in, so the board marks only what a runner reported.
    */
-  gitIdentityMissing: z8.array(GitIdentityPartSchema).optional(),
+  gitIdentityMissing: z9.array(GitIdentityPartSchema).optional(),
   /** Turns the runner runs at once, or null for no limit. */
-  slots: z8.number().int().positive().nullable(),
+  slots: z9.number().int().positive().nullable(),
   /** Turns the runner is still running, when it registers again; the server fails the rest of its turns. */
-  turns: z8.array(UlidSchema).default([])
+  turns: z9.array(UlidSchema).default([])
 });
-var RunnerWelcomeSchema = z8.object({ name: NameSchema, version: z8.string() });
-var RunnerEnrollRequestSchema = z8.object({
-  protocol: z8.number().int().positive(),
-  version: z8.string().min(1).max(64),
-  hostname: z8.string().min(1).max(253),
+var RunnerWelcomeSchema = z9.object({ name: NameSchema, version: z9.string() });
+var RunnerEnrollRequestSchema = z9.object({
+  protocol: z9.number().int().positive(),
+  version: z9.string().min(1).max(64),
+  hostname: z9.string().min(1).max(253),
   os: RunnerOsSchema,
-  clis: z8.array(CliKindSchema).max(8),
-  capabilities: z8.array(z8.string().min(1).max(64)).max(32).default([])
+  clis: z9.array(CliKindSchema).max(8),
+  capabilities: z9.array(z9.string().min(1).max(64)).max(32).default([])
 });
-var RunnerEnrollmentSchema = z8.object({
-  deviceCode: z8.string().min(1),
-  userCode: z8.string().min(1),
+var RunnerEnrollmentSchema = z9.object({
+  deviceCode: z9.string().min(1),
+  userCode: z9.string().min(1),
   expiresAt: IsoDateTimeSchema,
-  intervalMs: z8.number().int().positive()
+  intervalMs: z9.number().int().positive()
 });
-var RunnerEnrollPollSchema = z8.object({ deviceCode: z8.string().min(1) });
-var RunnerEnrollStatusSchema = z8.discriminatedUnion("status", [
-  z8.object({ status: z8.literal("pending") }),
-  z8.object({ status: z8.literal("approved"), name: NameSchema, token: z8.string().min(1) }),
-  z8.object({ status: z8.literal("denied") })
+var RunnerEnrollPollSchema = z9.object({ deviceCode: z9.string().min(1) });
+var RunnerEnrollStatusSchema = z9.discriminatedUnion("status", [
+  z9.object({ status: z9.literal("pending") }),
+  z9.object({ status: z9.literal("approved"), name: NameSchema, token: z9.string().min(1) }),
+  z9.object({ status: z9.literal("denied") })
 ]);
-var PendingEnrollmentSchema = z8.object({
-  userCode: z8.string().min(1),
-  hostname: z8.string(),
+var PendingEnrollmentSchema = z9.object({
+  userCode: z9.string().min(1),
+  hostname: z9.string(),
   os: RunnerOsSchema,
-  clis: z8.array(CliKindSchema),
-  capabilities: z8.array(z8.string()),
-  version: z8.string(),
+  clis: z9.array(CliKindSchema),
+  capabilities: z9.array(z9.string()),
+  version: z9.string(),
   requestedAt: IsoDateTimeSchema,
   expiresAt: IsoDateTimeSchema
 });
-var ProjectRepoSchema = z8.object({
+var ProjectRepoSchema = z9.object({
   slug: NameSchema,
-  origin: z8.string().nullable(),
-  defaultBranch: z8.string().min(1),
+  origin: z9.string().nullable(),
+  defaultBranch: z9.string().min(1),
   /**
    * The board lands finished tasks on the default branch, itself or through their pull requests,
    * so the runner lets nothing else move it.
    */
-  boardLands: z8.boolean()
+  boardLands: z9.boolean()
 });
-var TurnWorkspaceSchema = z8.discriminatedUnion("kind", [
-  z8.object({
-    kind: z8.literal("home"),
+var TurnWorkspaceSchema = z9.discriminatedUnion("kind", [
+  z9.object({
+    kind: z9.literal("home"),
     thread: UlidSchema.optional(),
     channel: NameSchema.optional()
   }),
-  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. */
@@ -1411,130 +1459,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, limit) {
   if (/^Binary files .* differ$/m.test(patch)) {
@@ -1548,69 +1596,88 @@ function patchHunks(patch, limit) {
   const cut = hunks.lastIndexOf("\n", limit);
   return { patch: hunks.slice(0, cut === -1 ? limit : cut), truncated: true };
 }
-var WorkspaceConversationSchema = z8.discriminatedUnion("kind", [
-  z8.object({ kind: z8.literal("thread"), id: UlidSchema }),
-  z8.object({ kind: z8.literal("channel"), scope: NameSchema, name: NameSchema })
+var TurnImageReadSchema = z9.object({
+  turnId: UlidSchema,
+  path: ImagePathSchema
+});
+var ImageRefusalSchema = z9.enum(["missing", "outside", "not_image", "too_big"]);
+var TurnImageSchema = z9.discriminatedUnion("kind", [
+  z9.object({
+    kind: z9.literal("image"),
+    type: ImageTypeSchema,
+    size: z9.number().int().positive(),
+    content: z9.string()
+  }),
+  z9.object({ kind: z9.literal("refused"), why: ImageRefusalSchema, detail: z9.string() })
+]);
+var WorkspaceConversationSchema = z9.discriminatedUnion("kind", [
+  z9.object({ kind: z9.literal("thread"), id: UlidSchema }),
+  z9.object({ kind: z9.literal("channel"), scope: NameSchema, name: NameSchema })
 ]);
-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;
@@ -1619,7 +1686,7 @@ function isSafeRelativePath(file) {
 }
 
 // packages/shared/dist/turns.js
-var TriggerKindSchema = z9.enum([
+var TriggerKindSchema = z10.enum([
   "mention",
   "stage",
   "task_done",
@@ -1633,11 +1700,11 @@ var TriggerKindSchema = z9.enum([
   "closing",
   "cron"
 ]);
-var TriggerSchema = z9.object({
+var TriggerSchema = z10.object({
   kind: TriggerKindSchema,
   from: NameSchema.optional(),
-  fromUser: z9.boolean().default(false),
-  reason: z9.string().default(""),
+  fromUser: z10.boolean().default(false),
+  reason: z10.string().default(""),
   taskId: UlidSchema.optional(),
   messageId: UlidSchema.optional(),
   /** The channel the waking message was posted in. */
@@ -1645,17 +1712,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}`);
@@ -1666,7 +1733,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,
@@ -1677,31 +1744,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,
@@ -1709,49 +1776,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",
@@ -1767,16 +1834,16 @@ var OPS_SIGNAL_KINDS = [
   "stuck_workspace",
   "cron_failing"
 ];
-var OpsSignalKindSchema = z10.enum(OPS_SIGNAL_KINDS);
-var OpsSignalSchema = z10.object({
+var OpsSignalKindSchema = z11.enum(OPS_SIGNAL_KINDS);
+var OpsSignalSchema = z11.object({
   kind: OpsSignalKindSchema,
   /** Identifies the condition, for example `backlog:demo:engineer`, so a persisting one is not logged again every pass. */
-  key: z10.string().min(1),
+  key: z11.string().min(1),
   /** One line a reader can act on. */
-  summary: z10.string().min(1),
+  summary: z11.string().min(1),
   /** The counter or timer value behind the signal. */
-  value: z10.number(),
-  threshold: z10.number().optional(),
+  value: z11.number(),
+  threshold: z11.number().optional(),
   project: NameSchema.optional(),
   agent: NameSchema.optional(),
   role: NameSchema.optional(),
@@ -1784,8 +1851,8 @@ var OpsSignalSchema = z10.object({
 });
 
 // packages/shared/dist/metrics.js
-import { z as z11 } from "zod";
-var MetricsWindowSchema = z11.enum(["24h", "7d", "all"]);
+import { z as z12 } from "zod";
+var MetricsWindowSchema = z12.enum(["24h", "7d", "all"]);
 var METRICS_WINDOW_MS = {
   "24h": 24 * 36e5,
   "7d": 7 * 24 * 36e5,
@@ -1796,9 +1863,9 @@ function isBoardAction(tool) {
   const verb = /^mcp__board__(.+)$/.exec(tool)?.[1];
   return verb !== void 0 && !READ_VERBS.some((read2) => read2 === verb);
 }
-var CountSchema = z11.number().int().nonnegative();
-var MsSchema = z11.number().nonnegative();
-var MetricsSchema = z11.object({
+var CountSchema = z12.number().int().nonnegative();
+var MsSchema = z12.number().nonnegative();
+var MetricsSchema = z12.object({
   window: MetricsWindowSchema,
   since: IsoDateTimeSchema.nullable(),
   until: IsoDateTimeSchema,
@@ -1806,12 +1873,12 @@ var MetricsSchema = z11.object({
    * Finished turns that changed nothing on the board. Reflections are left out, since they write
    * memory, not the board; turns without a transcript are counted apart, their actions unknown.
    */
-  idle: z11.object({
+  idle: z12.object({
     turns: CountSchema,
     idle: CountSchema,
     unknown: CountSchema,
-    byTrigger: z11.array(z11.object({ trigger: z11.string(), turns: CountSchema, idle: CountSchema })),
-    byAgent: z11.array(z11.object({
+    byTrigger: z12.array(z12.object({ trigger: z12.string(), turns: CountSchema, idle: CountSchema })),
+    byAgent: z12.array(z12.object({
       agent: NameSchema,
       role: NameSchema.nullable(),
       turns: CountSchema,
@@ -1819,33 +1886,33 @@ var MetricsSchema = z11.object({
     }))
   }),
   /** Work sent back to an earlier stage: over the tasks finished in the window, and by where. */
-  sentBack: z11.object({
+  sentBack: z12.object({
     finished: CountSchema,
     sendBacks: CountSchema,
     tasksSentBack: CountSchema,
-    byStage: z11.array(z11.object({ project: NameSchema, stage: z11.string(), count: CountSchema })),
-    bySender: z11.array(z11.object({ agent: NameSchema, count: CountSchema }))
+    byStage: z12.array(z12.object({ project: NameSchema, stage: z12.string(), count: CountSchema })),
+    bySender: z12.array(z12.object({ agent: NameSchema, count: CountSchema }))
   }),
   /** Posts in the threads of the tasks finished in the window, the board's own notices left out. */
-  messages: z11.object({
+  messages: z12.object({
     finished: CountSchema,
     messages: CountSchema,
-    byProject: z11.array(z11.object({ project: NameSchema, finished: CountSchema, messages: CountSchema })),
-    busiest: z11.array(z11.object({
+    byProject: z12.array(z12.object({ project: NameSchema, finished: CountSchema, messages: CountSchema })),
+    busiest: z12.array(z12.object({
       taskId: UlidSchema,
-      title: z11.string(),
+      title: z12.string(),
       project: NameSchema,
       messages: CountSchema
     }))
   }),
   /** Time from a mention to the start of the turn it woke, in the conversation it was made in. */
-  latency: z11.object({
+  latency: z12.object({
     mentions: CountSchema,
     /** Mentions no turn has followed yet. */
     unanswered: CountSchema,
     medianMs: MsSchema.nullable(),
     slowestMs: MsSchema.nullable(),
-    byAgent: z11.array(z11.object({
+    byAgent: z12.array(z12.object({
       agent: NameSchema,
       mentions: CountSchema,
       medianMs: MsSchema,
@@ -1853,93 +1920,93 @@ var MetricsSchema = z11.object({
     }))
   }),
   /** The user's decisions: proposals decided, questions answered, and stages passed or sent back. */
-  decisions: z11.object({
+  decisions: z12.object({
     total: CountSchema,
-    byDay: z11.array(z11.object({
-      day: z11.string(),
+    byDay: z12.array(z12.object({
+      day: z12.string(),
       proposals: CountSchema,
       answers: CountSchema,
       stages: CountSchema
     }))
   }),
   /** Tasks that needed a capability no connected runner offered, and whether they still do. */
-  blocked: z11.array(z11.object({
+  blocked: z12.array(z12.object({
     taskId: UlidSchema,
-    title: z11.string().nullable(),
+    title: z12.string().nullable(),
     project: NameSchema.nullable(),
-    summary: z11.string(),
+    summary: z12.string(),
     firstAt: IsoDateTimeSchema,
     lastAt: IsoDateTimeSchema,
-    holds: z11.boolean()
+    holds: z12.boolean()
   }))
 });
-var CitizenTokensSchema = z11.object({
+var CitizenTokensSchema = z12.object({
   agent: NameSchema,
   turns: CountSchema,
   withUsage: CountSchema,
   usage: UsageSchema.nullable()
 });
-var TokenUseSchema = z11.object({
+var TokenUseSchema = z12.object({
   window: MetricsWindowSchema,
   since: IsoDateTimeSchema.nullable(),
   until: IsoDateTimeSchema,
-  citizens: z11.array(CitizenTokensSchema)
+  citizens: z12.array(CitizenTokensSchema)
 });
 
 // packages/shared/dist/config.js
-import { z as z12 } from "zod";
-var LogLevelSchema = z12.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
-var GithubSignInSchema = z12.object({
-  clientId: z12.string().min(1),
-  clientSecret: z12.string().min(1),
+import { z as z13 } from "zod";
+var LogLevelSchema = z13.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
+var GithubSignInSchema = z13.object({
+  clientId: z13.string().min(1),
+  clientSecret: z13.string().min(1),
   /** Logins, lowercased; GitHub logins are case-insensitive. */
-  users: z12.array(z12.string().min(1)).min(1)
+  users: z13.array(z13.string().min(1)).min(1)
 });
-var ServerConfigSchema = z12.object({
-  dataDir: z12.string().min(1),
-  host: z12.string().min(1),
-  port: z12.number().int().positive().max(65535),
+var ServerConfigSchema = z13.object({
+  dataDir: z13.string().min(1),
+  host: z13.string().min(1),
+  port: z13.number().int().positive().max(65535),
   /**
    * An address every runner's agents reach this server at, for example https://board.example, or
    * null for each runner to use the address it reaches the server at itself.
    */
-  publicUrl: z12.string().min(1).nullable(),
+  publicUrl: z13.string().min(1).nullable(),
   logLevel: LogLevelSchema,
   /** Turns running at once across every runner, or null for no limit beyond each runner's own. */
-  concurrency: z12.number().int().positive().nullable(),
+  concurrency: z13.number().int().positive().nullable(),
   /** How long one turn may run before it is stopped, or null for no limit. */
-  turnTimeoutMs: z12.number().int().positive().nullable(),
+  turnTimeoutMs: z13.number().int().positive().nullable(),
   /** Rounds of tool calls one Claude turn may take, or null for no limit. */
-  toolRounds: z12.number().int().positive().nullable(),
+  toolRounds: z13.number().int().positive().nullable(),
   /** How long a resident session stays warm after its last turn. */
-  residentIdleMs: z12.number().int().positive(),
+  residentIdleMs: z13.number().int().positive(),
   /** Signing in to the board with GitHub, or null when only a token lets anyone in. */
   github: GithubSignInSchema.nullable(),
   /**
    * Reverse proxies in front of the server whose X-Forwarded-For entries name the client, for the
    * rate limits on what anyone may ask without a token: 0 when clients connect directly.
    */
-  trustedProxies: z12.number().int().min(0).max(16)
+  trustedProxies: z13.number().int().min(0).max(16)
 });
-var RunnerConfigSchema = z12.object({
+var RunnerConfigSchema = z13.object({
   /** The board server, for example http://127.0.0.1:4700. */
-  serverUrl: z12.string().url(),
+  serverUrl: z13.string().url(),
   /**
    * The runner's token, from `runner add`, or null for the one it saved when it was enrolled, or
    * to enroll it.
    */
-  token: z12.string().min(1).nullable(),
+  token: z13.string().min(1).nullable(),
   /** The runner's own data directory: the board mirror, agent homes, repositories, worktrees. */
-  dataDir: z12.string().min(1),
+  dataDir: z13.string().min(1),
   logLevel: LogLevelSchema,
   /** Turns this machine runs at once, or null for no limit. */
-  slots: z12.number().int().positive().nullable(),
-  clis: z12.array(CliKindSchema).min(1),
-  capabilities: z12.array(z12.string())
+  slots: z13.number().int().positive().nullable(),
+  clis: z13.array(CliKindSchema).min(1),
+  capabilities: z13.array(z13.string())
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.3.22";
+var STELLARIS_VERSION = "0.3.23";
 
 // packages/shared/dist/mentions.js
 import { parse, postprocess, preprocess } from "micromark";
@@ -2657,32 +2724,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()
-});
-var TaskPayload = z13.object({
-  taskId: z13.string(),
-  project: z13.string(),
-  from: z13.string().optional()
-});
-var MessagePayload = z13.object({
-  id: z13.string().optional(),
-  channel: z13.string(),
-  thread: z13.string().nullable().optional(),
-  mentions: z13.array(z13.string()).default([])
-});
-var SteeredPayload = z13.object({ messages: z13.array(z13.string()) });
-var SignalPayload = z13.object({
-  kind: z13.string(),
-  key: z13.string(),
-  summary: z13.string(),
-  taskId: z13.string().optional(),
-  project: z13.string().optional()
+import { z as z14 } from "zod";
+var TurnPayload = z14.object({
+  turnId: z14.string().optional(),
+  project: z14.string(),
+  thread: z14.string().optional(),
+  channel: z14.string().optional(),
+  trigger: z14.string()
+});
+var TaskPayload = z14.object({
+  taskId: z14.string(),
+  project: z14.string(),
+  from: z14.string().optional()
+});
+var MessagePayload = z14.object({
+  id: z14.string().optional(),
+  channel: z14.string(),
+  thread: z14.string().nullable().optional(),
+  mentions: z14.array(z14.string()).default([])
+});
+var SteeredPayload = z14.object({ messages: z14.array(z14.string()) });
+var SignalPayload = z14.object({
+  kind: z14.string(),
+  key: z14.string(),
+  summary: z14.string(),
+  taskId: z14.string().optional(),
+  project: z14.string().optional()
 });
 function median(values) {
   const sorted = values.toSorted((a, b) => a - b);
@@ -2972,19 +3039,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) {
@@ -3230,6 +3297,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");
   }
@@ -3265,27 +3339,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) {
@@ -3324,7 +3398,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");
@@ -3349,7 +3423,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";
@@ -3363,10 +3437,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.";
@@ -3498,6 +3573,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();
@@ -3562,7 +3638,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;
@@ -3592,13 +3669,13 @@ var Board = class _Board {
       await this.openAsksChannel();
     }
     if (pending.includes(KNOWLEDGE_REMOVAL)) {
-      await this.grantBesideKnowledge("remove_knowledge");
+      await this.grantBeside("write_knowledge", "remove_knowledge");
     }
     if (pending.includes(CHANNEL_CONVERSATIONS)) {
       await this.startChannelCursors();
     }
     if (pending.includes(DASHBOARD_UPDATES)) {
-      await this.grantBesideKnowledge("update_dashboard");
+      await this.grantBeside("write_knowledge", "update_dashboard");
       await this.rewordDashboards();
     }
     if (pending.includes(CRON_VERBS)) {
@@ -3607,6 +3684,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] });
   }
   /**
@@ -3648,12 +3728,12 @@ var Board = class _Board {
     }
   }
   /**
-   * Grants `verb` once to every charter granting `write_knowledge`, the work roles' charters in
-   * practice; seed roles have it from their seed.
+   * Grants `verb` once to every charter granting `beside`, the work roles' charters in practice;
+   * seed roles have it from their seed.
    */
-  async grantBesideKnowledge(verb) {
+  async grantBeside(beside, verb) {
     for (const charter of await this.listRoles()) {
-      if (charter.verbs.includes("write_knowledge") && !charter.verbs.includes(verb)) {
+      if (charter.verbs.includes(beside) && !charter.verbs.includes(verb)) {
         await this.writeRoleUnlocked(USER_NAME, { ...charter, verbs: [...charter.verbs, verb] }, { verbsAdded: [verb] });
       }
     }
@@ -3811,7 +3891,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;
@@ -3889,7 +3969,7 @@ var Board = class _Board {
    * turns, so it follows nothing now.
    */
   async renameInboxCursors() {
-    const Legacy = z15.object({ inbox: z15.string().nullable() });
+    const Legacy = z16.object({ inbox: z16.string().nullable() });
     for (const agent2 of await this.listAgents()) {
       const file = this.paths.agentCursors(agent2.name);
       if (await exists(file)) {
@@ -3935,7 +4015,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));
@@ -4252,7 +4332,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(project2) {
@@ -4272,7 +4352,7 @@ ${charter.purpose}
    */
   async knowledgeAt(file, project2, topic) {
     const { data, body } = await readLooseMarkdown(file);
-    const revision = z15.number().int().min(0).safeParse(data["revision"]);
+    const revision = z16.number().int().min(0).safeParse(data["revision"]);
     const updatedBy = NameSchema.safeParse(data["updatedBy"]);
     const updatedAt = IsoDateTimeSchema.safeParse(data["updatedAt"]);
     return {
@@ -5235,6 +5315,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 = [];
@@ -5626,6 +5760,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
@@ -6455,6 +6596,8 @@ ${rationale}`}`);
         return this.updateCron(actor, VerbInputs.update_cron.parse(input));
       case "remove_cron":
         return this.removeCron(actor, VerbInputs.remove_cron.parse(input));
+      case "upload_image":
+        return this.uploadImage(actor, VerbInputs.upload_image.parse(input));
       default:
         throw new BoardError("VALIDATION", `unknown verb ${String(verb)}`);
     }
@@ -6501,7 +6644,7 @@ ${rationale}`}`);
   }
   async readAgentRoleBody(agent2) {
     const file = this.paths.agentRole(agent2);
-    return await exists(file) ? (await readMarkdown(file, z15.record(z15.string(), z15.unknown()))).body : "";
+    return await exists(file) ? (await readMarkdown(file, z16.record(z16.string(), z16.unknown()))).body : "";
   }
   /** The steps of one finished turn, as the runner handed them over when it ended. */
   /**
@@ -6909,7 +7052,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 {
@@ -7183,7 +7326,7 @@ ${charter.purpose}
 
 ${charter.purpose}
 
-Route every lesson with one question: about me, my craft, or the user, it goes in memory/core.md; about this codebase, it goes in the project's knowledge directory; something everyone should know, post it.
+Route every lesson with one question: about me, my craft, or the user, it goes in memory/core.md; about how this codebase behaves, it goes in the repo's AGENTS.md or README; about this project as a place (runners, access, flow, where results live), it goes in the project's knowledge; something everyone should know, post it.
 ` + (seed.length === 0 ? "" : `
 ${SEED_INSTRUCTIONS_HEADING}
 
@@ -7200,7 +7343,7 @@ ${seed}
         continue;
       }
       const file = this.paths.agentRole(agent2.name);
-      const body = await exists(file) ? (await readMarkdown(file, z15.record(z15.string(), z15.unknown()))).body : "";
+      const body = await exists(file) ? (await readMarkdown(file, z16.record(z16.string(), z16.unknown()))).body : "";
       const at = body.indexOf(`
 ${SEED_INSTRUCTIONS_HEADING}
 `);