moonmill 0.1.0 → 0.2.0

package/dist/main.js

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
-import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { basename, dirname, isAbsolute, join, posix, relative, resolve } from "node:path";
 import { parseArgs, promisify } from "node:util";
 import { z } from "zod";
-import { chmod, lstat, mkdir, mkdtemp, open, readFile, readdir, readlink, realpath, rename, rm, rmdir, stat, symlink, utimes, writeFile } from "node:fs/promises";
+import { appendFile, chmod, lstat, mkdir, mkdtemp, open, readFile, readdir, readlink, realpath, rename, rm, rmdir, stat, symlink, utimes, writeFile } from "node:fs/promises";
 import { arch, homedir, hostname, release, tmpdir, userInfo, version } from "node:os";
 import { createHash, randomUUID } from "node:crypto";
 import { execFile, spawn } from "node:child_process";
 import { RuntimeFailureError, SessionNotFoundError } from "@botiverse/oar/browser";
-import { promptAndWait, toolResultText, viewOf } from "@botiverse/oar/observe";
+import { eventsOf, promptAndWait, toolResultText, viewOf } from "@botiverse/oar/observe";
 import { TomlError, parse } from "smol-toml";
 import { parse as parse$1, stringify } from "yaml";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { WebSocket } from "ws";
 import { once } from "node:events";
-import { setTimeout as setTimeout$1 } from "node:timers/promises";
 //#region ../protocol/src/activity.ts
 /** How live activity is paced and how long it lasts. */
 const LIVE_ACTIVITY = {
@@ -110,10 +110,123 @@ function filedId(what) {
 /** A git commit's id in full: 40 hexadecimal digits (SHA-1), or 64 (SHA-256). */
 const COMMIT_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
 //#endregion
+//#region ../protocol/src/images.ts
+/** How many images one document may carry, and how large each may be. */
+const IMAGE_LIMITS = {
+	/** Images in one document. */
+	images: 20,
+	/** Bytes of one image. */
+	bytes: 10485760,
+	/** Characters of what one shows (`alt`). */
+	alt: 500
+};
+/** The image types a document may carry. */
+const IMAGE_TYPES = [
+	"image/png",
+	"image/jpeg",
+	"image/gif",
+	"image/webp"
+];
+const imageType = z.enum(IMAGE_TYPES);
+/**
+* An image's key in the image store, under its Owner's prefix: the SHA-256 of its bytes, hex (a
+* Node computes it with `node:crypto`, a page with `crypto.subtle`).
+*/
+const imageKey = z.string().regex(/^[0-9a-f]{64}$/, "Not an image's key");
+/** One image a document names: its key in the image store, its type and what it shows. */
+const documentImage = z.object({
+	key: imageKey,
+	mimeType: imageType,
+	/** What it shows, for someone who can't see it. */
+	alt: z.string().max(IMAGE_LIMITS.alt).optional()
+});
+/** A document's images, in the order it shows them. */
+const documentImages = z.array(documentImage).max(IMAGE_LIMITS.images);
+/**
+* An image as a document names it without its bytes or a key: its type and what it shows. A
+* conversation's images, which stay on their Node (a Help Request's question and reply), are named
+* so, and a Workspace's file so describes the image in it.
+*/
+const imageAbout = documentImage.pick({
+	mimeType: true,
+	alt: true
+});
+/**
+* A short-lived address in the image store, signed for one image and one request: its URL, and the
+* headers the request must carry as signed. A path (on a Platform keeping images on its own disk)
+* is the Platform's: resolve it against the Platform's address. Send it nothing else, a Node's
+* credential least of all.
+*/
+const imageAddress = z.object({
+	url: z.string().min(1),
+	headers: z.record(z.string(), z.string()).optional()
+});
+/** One image someone means to put into the image store: its key, its type and how large it is. */
+const imageToUpload = z.object({
+	key: imageKey,
+	mimeType: imageType,
+	bytes: z.int().positive().max(IMAGE_LIMITS.bytes)
+});
+/** The images of one document to put into the image store. */
+const imagesToUpload = z.array(imageToUpload).min(1).max(IMAGE_LIMITS.images);
+/**
+* Where to put one image: the address to PUT its bytes to, with the headers it names, or null when
+* the store keeps it already.
+*/
+const imageUpload = z.object({
+	key: imageKey,
+	address: imageAddress.nullable()
+});
+/** One image sent with words, as the head names it: its type by its first bytes, and its size. */
+const sentImage = z.object({
+	mimeType: imageType,
+	bytes: z.int().positive().max(IMAGE_LIMITS.bytes)
+});
+z.array(sentImage).max(IMAGE_LIMITS.images);
+/** An image's type, from its first bytes; null for anything that isn't one of `IMAGE_TYPES`. */
+function imageTypeOf(bytes) {
+	if (holds$1(bytes, 0, [
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10
+	])) return "image/png";
+	if (holds$1(bytes, 0, [
+		255,
+		216,
+		255
+	])) return "image/jpeg";
+	if (holds$1(bytes, 0, "GIF8")) return "image/gif";
+	if (holds$1(bytes, 0, "RIFF") && holds$1(bytes, 8, "WEBP")) return "image/webp";
+	return null;
+}
+/** Whether `bytes` hold `expected` from `at`: these bytes, or this ASCII text's. */
+function holds$1(bytes, at, expected) {
+	for (let index = 0; index < expected.length; index++) {
+		const byte = typeof expected === "string" ? expected.charCodeAt(index) : expected[index];
+		if (bytes[at + index] !== byte) return false;
+	}
+	return true;
+}
+//#endregion
 //#region ../protocol/src/runs.ts
 /** A Workpiece's brief: what the Owner asks for when they dispatch it. */
 const brief = z.string().trim().min(1).max(2e4);
-z.enum([
+/**
+* Where a Workstation Task is. `queued` until its Agent's Node starts it, `running` while the Agent
+* works, `handed-off` once the Agent delivered its Hand-off, `being-checked` while the Inspector of
+* the Belt it goes onto judges it against the Belt's criteria (ADR-0014), `accepted` once the
+* Hand-off moved on (onto a Belt without criteria or at the end of the Pipeline at once, once it
+* passed its check, or once the Owner accepted it anyway), `rejected` when it failed its check
+* (until the Owner accepts it anyway, if they do). `failed` and `timed-out` end a Task that
+* can't finish. `suspended` while its Agent waits for the Owner's reply to a Help Request, its
+* Session kept on its Node to resume with the reply.
+*/
+const WORKSTATION_TASK_STATUSES = [
 	"queued",
 	"running",
 	"suspended",
@@ -123,7 +236,8 @@ z.enum([
 	"accepted",
 	"failed",
 	"timed-out"
-]);
+];
+z.enum(WORKSTATION_TASK_STATUSES);
 /** How a Workstation Task ends without a Hand-off. */
 const TASK_FAILURE_STATUSES = ["failed", "timed-out"];
 /**
@@ -186,31 +300,15 @@ function shortOutcome(outcome) {
 }
 /**
 * What keeps a Hand-off a document rather than a carrier of materials (ADR-0008): some text, a few
-* small images, and references to everything else. Together they stay well inside one message of
-* the Node link.
+* images (as many and as large as any document's: `IMAGE_LIMITS`, kept in the image store and named
+* by key: images.ts), and references to everything else. Together they stay well inside one
+* message of the Node link.
 */
 const HAND_OFF_LIMITS = {
 	/** Characters of Markdown. */
 	markdown: 1e5,
-	images: 4,
-	/** Bytes of one image, before base64. */
-	imageBytes: 524288,
 	references: 20
 };
-/** The image types a Hand-off may carry. */
-const HAND_OFF_IMAGE_TYPES = [
-	"image/png",
-	"image/jpeg",
-	"image/gif",
-	"image/webp"
-];
-const handOffImage = z.object({
-	mimeType: z.enum(HAND_OFF_IMAGE_TYPES),
-	/** The image, base64. */
-	data: z.base64().max(Math.ceil(HAND_OFF_LIMITS.imageBytes / 3) * 4),
-	/** What it shows, for someone who can't see it. */
-	alt: z.string().max(500).optional()
-});
 /** Material the Hand-off points at, where it lives: a label, and a URL or a pinned identifier. */
 const handOffReference = z.object({
 	label: z.string().trim().min(1).max(200),
@@ -219,25 +317,35 @@ const handOffReference = z.object({
 /** The document an Agent delivers at the end of its Workstation Task (ADR-0008). */
 const handOff = z.object({
 	markdown: z.string().trim().min(1).max(HAND_OFF_LIMITS.markdown),
-	images: z.array(handOffImage).max(HAND_OFF_LIMITS.images),
+	images: documentImages,
 	references: z.array(handOffReference).max(HAND_OFF_LIMITS.references)
 });
-z.enum([
+/**
+* Where a check of a Hand-off is (ADR-0014): `queued` until its Inspector's Node starts it,
+* `running` while the Inspector judges, then ended: `passed`, `failed` (with annotations), or
+* `no-judgement` when its Session ended without one (it crashed, timed out, lost its Node, or
+* never called the check tool).
+*/
+const CHECK_STATUSES = [
 	"queued",
 	"running",
 	"passed",
 	"failed",
 	"no-judgement"
-]);
+];
+z.enum(CHECK_STATUSES);
 /** An Inspector's annotations: Markdown, bounded like a Hand-off's text. */
 const annotations = z.string().trim().min(1).max(HAND_OFF_LIMITS.markdown);
 /**
 * An Inspector's judgement of a Hand-off against its Belt's criteria: passed, or failed with
-* annotations saying which criteria weren't met and why.
+* annotations saying which criteria weren't met and why, and the images that show what is wrong
+* beside them (#184), named in the image store as a Hand-off's are (images.ts). A passing one
+* carries neither. (A judgement from protocol 24 or before, in an outbox or the ledger, has none.)
 */
 const judgement = z.discriminatedUnion("outcome", [z.object({ outcome: z.literal("passed") }), z.object({
 	outcome: z.literal("failed"),
-	annotations
+	annotations,
+	images: documentImages.default([])
 })]);
 /**
 * Where a Workpiece holds on a paused line, and why (spec "Pausing a line"): each step that would
@@ -288,7 +396,17 @@ const WORKSPACE_FOLDERS = {
 	/** An Inspector's Workspace's Hand-off under check. */
 	underCheck: "hand-off",
 	/** A Rework's Workspace's Hand-off of the attempt it follows. */
-	previousAttempt: "previous-attempt"
+	previousAttempt: "previous-attempt",
+	/**
+	* A work Session's Help Requests (#185): the images each question asked with, copied as they were
+	* then, one folder per question.
+	*/
+	helpRequest: "help-request",
+	/**
+	* A chat's Workspace (#187): the images each of the Owner's messages came with, one folder per
+	* turn.
+	*/
+	chatTurns: "chat-turns"
 };
 /**
 * Every name at a Workspace's root that is the Node's own: its folders and the instructions files
@@ -450,6 +568,8 @@ z.object({
 	outcome: sessionOutcome.nullable(),
 	usage: tokenUsage.nullable()
 });
+/** What a chat turn's prompt calls the images the Owner's message came with: "This message's…". */
+const CHAT_MESSAGE_IMAGES = "this message";
 /**
 * What the Owner calls an Agent, a Factory, a Workshop, a Pipeline or a Workstation, and the name
 * they give themselves (the Owner account's, renamed in the Account panel).
@@ -461,7 +581,7 @@ const definitionName = z.string().trim().min(1).max(100);
 * at its back-left corner's from its Factory's, and a Pipeline at its Intake's from its Workshop's
 * back-left corner (ADR-0015). Nothing stores a size: each is as big as what it holds needs.
 */
-const spot = z.object({
+const spot$1 = z.object({
 	x: z.number(),
 	z: z.number()
 });
@@ -510,6 +630,22 @@ const attemptBudget = z.number().int().min(1).max({
 	human: 1
 }.max);
 /**
+* How long an Agent Workstation's Task may be at work in one segment of its Session before it
+* times out, in minutes (#174): counted from the Task's start, and afresh from each resume after
+* the Owner's reply to a Help Request, a suspended Task never timing out. Set per Workstation by
+* the Owner, within bounds: less than `min` would stop every Task at once, more than `max` leave a
+* stuck one running for days unnoticed. A Human Workstation has none to set (the Owner's audit
+* never times out): it holds the default, unused.
+*/
+const TIME_LIMIT = {
+	/** What a new Agent Workstation gets, and what every one had before it could be set. */
+	default: 60,
+	min: 5,
+	/** 72 hours. */
+	max: 4320
+};
+const timeLimitMinutes = z.number().int().min(TIME_LIMIT.min).max(TIME_LIMIT.max);
+/**
 * Whether an Agent can run on this Runtime: installed and signed in, as its Node last reported. A
 * sign-in the Node couldn't confirm counts as not signed in.
 */
@@ -1029,6 +1165,8 @@ const RECORD_LIMITS = {
 	tool: 200,
 	/** Characters of why a turn failed. */
 	reason: 2e3,
+	/** Images one prompt or tool call names: any past these go unnamed. */
+	images: 50,
 	/** Items in one part of the answer. */
 	itemsPerPart: 200,
 	/** Items in a whole record: what follows is left out, and the record says how many. */
@@ -1044,6 +1182,20 @@ function recordText(max) {
 		omitted: z.number().int().nonnegative()
 	});
 }
+/** The most images one segment of a record numbers: any past these go unnamed. */
+const MAX_SEGMENT_IMAGES = RECORD_LIMITS.items * RECORD_LIMITS.images;
+/**
+* An image a record names (#188): one a prompt carried, a file in the Session's Workspace, or one a
+* tool call returned, kept in the record itself. Named by where it is, never by a path: in segment
+* `segment`, the `index`th image (0, 1, 2…) of those its prompts carried and its tools returned, in
+* the order they came.
+*/
+const recordImage = z.object({
+	segment: z.number().int().positive(),
+	index: z.number().int().nonnegative().max(MAX_SEGMENT_IMAGES - 1)
+});
+/** The images a prompt or a tool call names, if any: absent when none. */
+const recordImages = z.array(recordImage).min(1).max(RECORD_LIMITS.images).optional();
 /**
 * How a tool call stands in the record: it returned (`ok`) or failed, it was still `running`
 * when the record ends, or it `ended` without a result its Runtime reported (its turn or Session
@@ -1125,7 +1277,8 @@ const recordItem = z.discriminatedUnion("kind", [
 	}),
 	z.object({
 		kind: z.literal("prompt"),
-		text: recordText(RECORD_LIMITS.prompt)
+		text: recordText(RECORD_LIMITS.prompt),
+		images: recordImages
 	}),
 	z.object({
 		kind: z.literal("text"),
@@ -1141,7 +1294,8 @@ const recordItem = z.discriminatedUnion("kind", [
 		tool: z.string().min(1).max(RECORD_LIMITS.tool),
 		input: recordText(RECORD_LIMITS.toolInput).nullable(),
 		result: z.enum(RECORD_TOOL_RESULTS),
-		output: recordText(RECORD_LIMITS.toolOutput).nullable()
+		output: recordText(RECORD_LIMITS.toolOutput).nullable(),
+		images: recordImages
 	}),
 	z.object({
 		kind: z.literal("turn-ended"),
@@ -1175,30 +1329,49 @@ const verdictText = z.string().trim().min(1).max(2e4);
 */
 const helpQuestion = z.string().trim().min(1).max(2e4);
 /**
+* The images a Verdict's guidance or note carries beside its words (spec #172, stories 8 and 9),
+* each named by its key in the image store, where the Owner's page put it first (ADR-0025). They
+* travel with the Workpiece as the words do. Absent for a Verdict given without images, and for
+* every one given before Verdicts carried them.
+*/
+const verdictImages = documentImages.optional();
+/**
 * The Verdicts the Owner rules with (spec stories 46, 48, 50): Approve (onward, with an optional
 * note), Send back (to an earlier Agent Workstation, with guidance), Rework with guidance (a fresh
 * round at the Ticket's Workstation), Accept anyway (the latest Hand-off moves on unchecked), Reply
 * & resume (a Help Request's answer), and Scrap (the Workpiece ends). Which ones a Ticket takes
-* depends on its category (`VERDICTS`).
+* depends on its category (`VERDICTS`). A Send back's or a Rework's guidance, and an Approve's note,
+* may carry images beside their words (`imagesOf`), never instead of them: an Approve with images
+* has a note (the Platform's Verdict rule refuses one without).
 */
 const verdict = z.discriminatedUnion("kind", [
 	z.object({
 		kind: z.literal("approve"),
-		note: verdictText.optional()
+		note: verdictText.optional(),
+		images: verdictImages
 	}),
 	z.object({
 		kind: z.literal("send-back"),
 		workstationId: z.string().min(1),
-		guidance: verdictText
+		guidance: verdictText,
+		images: verdictImages
 	}),
 	z.object({
 		kind: z.literal("rework"),
-		guidance: verdictText
+		guidance: verdictText,
+		images: verdictImages
 	}),
 	z.object({ kind: z.literal("accept-anyway") }),
 	z.object({
 		kind: z.literal("reply"),
-		reply: verdictText
+		reply: verdictText,
+		/**
+		* The images the reply came with (#186), named without their bytes: they went to the Node of
+		* the Task it resumes, into its Session's Workspace, and nowhere else (ADR-0025). The Agents
+		* after it are told how many there were. Absent from a reply in words alone, and from every
+		* reply given before images were.
+		*/
+		images: z.array(imageAbout).min(1).max(IMAGE_LIMITS.images).optional()
 	}),
 	z.object({ kind: z.literal("scrap") })
 ]);
@@ -1212,6 +1385,16 @@ const VERDICT_NAMES = {
 	scrap: "Scrap"
 };
 /**
+* Where a Verdict sends the Workpiece, as its stamp's ink shows it: `onward`, `back` for Rework,
+* or to its `end` (Scrap). The Desk's stamps, the courier robot's paper and a Showroom's moments
+* are inked so.
+*/
+const VERDICT_INK_KINDS = [
+	"onward",
+	"back",
+	"end"
+];
+/**
 * What the Owner wrote into a Verdict (spec story 54): the guidance of a Send back or a Rework with
 * guidance, an Approve's note, a Help Request's reply. Null for a Verdict that carries none.
 */
@@ -1229,6 +1412,20 @@ function wordsOf(given) {
 	}
 	return words;
 }
+/**
+* The images the Owner put beside the words of a Verdict (spec #172): its guidance's, or its note's,
+* in the image store. None for a Verdict that carries none, nor for a reply, whose images went to
+* its Node alone and are named without a key (#186).
+*/
+function imagesOf(given) {
+	let images = [];
+	switch (given.kind) {
+		case "send-back":
+		case "rework":
+		case "approve": images = given.images ?? [];
+	}
+	return images;
+}
 /** A Ticket's title: what it is about, in a line. */
 const ticketTitle = z.string().min(1).max(200);
 /** How the Owner sees a Ticket's number: T-1, T-2… per Owner. */
@@ -1344,15 +1541,55 @@ const NODE_TASKS_PATH = "/api/nodes/tasks";
 function nodeHandOffPath(taskId, handOffId) {
 	return `${NODE_TASKS_PATH}/${encodeURIComponent(taskId)}/hand-offs/${encodeURIComponent(handOffId)}`;
 }
-/** Where the Node fetches image `index` (0, 1, 2…) of that Hand-off, as its bytes: GET. */
-function nodeHandOffImagePath(taskId, handOffId, index) {
-	return `${nodeHandOffPath(taskId, handOffId)}/images/${index}`;
-}
-/** A Hand-off as the Node fetches it: its document, with each image's bytes fetched on its own. */
+/** A document's image as a Node fetches it: with an address in the image store to read it at. */
+const addressedImage = documentImage.extend({ address: imageAddress });
+/**
+* A Hand-off as the Node fetches it: its document, each image with an address signed for the Task
+* that fetched it, valid a while, to read its bytes from the image store at (never with the Node's
+* credential).
+*/
 const fetchedHandOff = handOff.extend({
 	id: z.string().min(1),
-	images: z.array(handOffImage.omit({ data: true })).max(HAND_OFF_LIMITS.images)
+	images: z.array(addressedImage).max(IMAGE_LIMITS.images)
+});
+/**
+* Where the Node fetches addresses to read the images of the brief of the Workpiece the Task
+* `taskId` it holds (or a check of it) works on: GET, answered `fetchedBrief`.
+*/
+function nodeBriefPath(taskId) {
+	return `${NODE_TASKS_PATH}/${encodeURIComponent(taskId)}/brief`;
+}
+/**
+* A brief's images as the Node fetches them: each with an address signed for the Task that
+* fetched it, valid a while, to read its bytes from the image store at (never with the Node's
+* credential). Its words are in the message starting the Session.
+*/
+const fetchedBrief = z.object({ images: z.array(addressedImage).max(IMAGE_LIMITS.images) });
+/**
+* Where the Node fetches the annotations of check `checkId`, which failed the attempt the Task
+* `taskId` it holds reworks (`previousAttempt`), with the images beside them (#184): GET.
+*/
+function nodeAnnotationsPath(taskId, checkId) {
+	return `${NODE_TASKS_PATH}/${encodeURIComponent(taskId)}/checks/${encodeURIComponent(checkId)}/annotations`;
+}
+/**
+* A failed check's annotations as the Node fetches them: their Markdown, and each image beside them
+* with an address signed for the Task that fetched it, as a Hand-off's are.
+*/
+const fetchedAnnotations = z.object({
+	annotations,
+	images: z.array(addressedImage).max(IMAGE_LIMITS.images)
 });
+/**
+* Where a Node asks where to put the images a message of its will name (a Hand-off's, a failed
+* judgement's), before it sends it: POST `nodeImageUploads`, answered `nodeImageUploadAnswer`, or
+* a `fetchRefusal`. It puts each image at its address itself, then sends the message, which the
+* Platform takes only once each image it names is in the image store (images.ts).
+*/
+const NODE_IMAGES_PATH = "/api/nodes/images";
+z.object({ images: imagesToUpload });
+/** Where to put each, in the order asked: null for one the image store keeps already. */
+const nodeImageUploadAnswer = z.object({ uploads: z.array(imageUpload) });
 /** What the Platform answers a fetch it refuses. */
 const fetchRefusal = z.object({ error: z.string() });
 const messageId = z.string().min(1).max(128);
@@ -1378,7 +1615,7 @@ const ackMessage = z.object({
 	outcome: ackOutcome,
 	reason: z.string().max(500).optional()
 });
-/** How long the Platform waits for a Node's whole answer, by default and at most. */
+/** How long the Platform waits for each part of a Node's answer, by default and at most. */
 const NODE_REQUEST_TIMEOUT_MS = {
 	default: 2e4,
 	max: 12e4
@@ -1388,6 +1625,36 @@ const MAX_ANSWER_PARTS = RECORD_LIMITS.items;
 /** A Task's or a check's id as a Node files its Session under it: never a path. */
 const sessionFiledId = filedId("an id");
 /**
+* The most bytes of an image one part of an answer carries: half a MiB of base64, so that a slow
+* link still hears from the Node well within its heartbeat timeout while an image goes.
+*/
+const IMAGE_PART_BYTES = 393216;
+/** One part of an image's bytes, base64: at most `IMAGE_PART_BYTES` of them. */
+const imagePartData = z.base64().min(1).max(IMAGE_PART_BYTES / 3 * 4);
+/**
+* What images the Platform hands a Node are for: a reply to the Help Request of Task `taskId`,
+* whose Session the Node keeps waiting for it (#186); or the Owner's message in turn `turn` of chat
+* `chatId` (#187).
+*/
+const handedTo = z.discriminatedUnion("of", [z.object({
+	of: z.literal("reply"),
+	taskId: sessionFiledId
+}), z.object({
+	of: z.literal("chat"),
+	chatId,
+	turn: chatTurn
+})]);
+/** One handing-over of images to a Node, by the id the Platform gives it: never a path. */
+const handingId = filedId("a handing-over's id");
+/**
+* The images a message names that the Platform handed its Node before it (`handed-image`): the
+* handing-over's id, and each image in the order handed, without its bytes.
+*/
+const handedImages = z.object({
+	handing: handingId,
+	images: z.array(imageAbout).min(1).max(IMAGE_LIMITS.images)
+});
+/**
 * A Session the Node ran, by the ids it files its record under (`sessions/<Task id>/`, a check's
 * in `check-<check id>/` there, a chat's in `sessions/chats/<chat id>/`, a Millwright's in
 * `sessions/millwright/<its id>/`), never by a path.
@@ -1411,6 +1678,37 @@ const recordedSession = z.discriminatedUnion("role", [
 		sessionId: millwrightSessionId
 	})
 ]);
+/** Which image of a document a Node keeps it is: 0, 1, 2… */
+const keptIndex = z.number().int().nonnegative().max(IMAGE_LIMITS.images - 1);
+/**
+* An image a Node keeps (ADR-0025), by the ids the Node filed it under, never a path:
+* - image `index` (0, 1, 2…) of a Help Request's question (#185), filed under its Task's id and its
+*   `help-request` message's id, in its Task's Workspace;
+* - image `index` of a Help Request's reply (#186), filed under its Task's id and the handing-over
+*   that brought it (`handing`), beside the question in its Task's Workspace;
+* - an image a Session's record names (#188), by its Session and where it is in the record
+*   (`recordImage`): one a prompt carried, in the Session's Workspace, or one a tool returned, in
+*   the record itself.
+*/
+const keptImage = z.discriminatedUnion("of", [
+	z.object({
+		of: z.literal("help-request"),
+		taskId: sessionFiledId,
+		question: filedId("a question's id"),
+		index: keptIndex
+	}),
+	z.object({
+		of: z.literal("help-reply"),
+		taskId: sessionFiledId,
+		handing: handingId,
+		index: keptIndex
+	}),
+	z.object({
+		of: z.literal("session-record"),
+		session: recordedSession,
+		...recordImage.shape
+	})
+]);
 /** What the Platform may ask a Node. */
 const nodeAsk = z.discriminatedUnion("about", [
 	z.object({
@@ -1425,6 +1723,20 @@ const nodeAsk = z.discriminatedUnion("about", [
 		about: z.literal("own-setup"),
 		runtime: runtimeId,
 		of: z.enum(["agent", "millwright"]).default("agent")
+	}),
+	z.object({
+		about: z.literal("image"),
+		image: keptImage
+	}),
+	z.object({
+		about: z.literal("handed-image"),
+		to: handedTo,
+		handing: handingId,
+		index: keptIndex,
+		at: z.number().int().nonnegative().max(IMAGE_LIMITS.bytes - 1),
+		last: z.boolean(),
+		mimeType: imageType,
+		data: imagePartData
 	})
 ]);
 /** One part of what a Node answers. */
@@ -1441,6 +1753,12 @@ const nodeAnswer = z.discriminatedUnion("kind", [
 		kind: z.literal("own-setup"),
 		setup: ownSetup
 	}),
+	z.object({
+		kind: z.literal("image"),
+		mimeType: imageType,
+		data: imagePartData
+	}),
+	z.object({ kind: z.literal("handed-image") }),
 	z.object({
 		kind: z.literal("refused"),
 		reason: z.string().min(1).max(500)
@@ -1448,11 +1766,15 @@ const nodeAnswer = z.discriminatedUnion("kind", [
 	z.object({
 		kind: z.literal("failed"),
 		reason: z.string().min(1).max(2e3)
+	}),
+	z.object({
+		kind: z.literal("gone"),
+		reason: z.string().min(1).max(500)
 	})
 ]);
 /**
-* The Platform asks the Node `ask`, and waits `timeoutMs` for the whole answer, after which the Node
-* needn't answer any more. Never kept, replayed or acknowledged.
+* The Platform asks the Node `ask`, and waits `timeoutMs` for each part of the answer, after which
+* the Node needn't answer any more. Never kept, replayed or acknowledged.
 */
 const requestMessage = z.object({
 	kind: z.literal("request"),
@@ -1462,7 +1784,7 @@ const requestMessage = z.object({
 });
 /**
 * Part `part` (0, 1, 2…) of the Node's answer to the request with id `request`; `last` once it is
-* the whole of it. A `refused` or `failed` part is always the last. Never kept, replayed or
+* the whole of it. A `refused`, `failed` or `gone` part is always the last. Never kept, replayed or
 * acknowledged.
 */
 const answerMessage = z.object({
@@ -1551,7 +1873,13 @@ const helpRequestMessage = z.object({
 	kind: z.literal("help-request"),
 	...reliableEnvelope,
 	taskId: taskId$1,
-	question: helpQuestion
+	question: helpQuestion,
+	/**
+	* The images the Agent asked with (#185), in its order, named without their bytes: the Node
+	* keeps copies of them in the Task's Workspace, filed under this message's `id`, which the
+	* Platform asks for each by (`keptImage`).
+	*/
+	images: z.array(imageAbout).max(IMAGE_LIMITS.images).default([])
 });
 /**
 * A Session of the Workstation Task ended (its work, or a check): how, and the tokens it used, or
@@ -1703,6 +2031,15 @@ const nodeMessage = z.discriminatedUnion("kind", [
 	answerMessage,
 	ackMessage
 ]);
+/**
+* The images in the image store a Node's message names (a Hand-off's, a failed judgement's), which
+* its Node puts there before it sends it, and which the Platform finds there before it takes it.
+*/
+function imagesNamedBy(message) {
+	if (message.kind === "hand-off") return message.handOff.images;
+	if (message.kind === "judgement" && message.judgement.outcome === "failed") return message.judgement.images;
+	return [];
+}
 /** The answer to `hello`: the Node is online. */
 const welcomeMessage = z.object({
 	kind: z.literal("welcome"),
@@ -1749,12 +2086,16 @@ const taskStartFields = {
 		skills: sessionBindings.default([])
 	}),
 	/**
-	* The Workpiece as it stands: its brief and the Hand-offs accepted so far, in Pipeline order, each
-	* named by its id and where it was made; the Node fetches them (`nodeHandOffPath`).
+	* The Workpiece as it stands: its brief, with the images it carries beside its words, each named
+	* by its key in the image store, which the Node reads through addresses it fetches for them
+	* (`nodeBriefPath`), and the Hand-offs accepted so far, in Pipeline order, each named by its id
+	* and where it was made; the Node fetches them (`nodeHandOffPath`). (A Session kept in an outbox
+	* from protocol 24 or before gets no images.)
 	*/
 	workpiece: z.object({
 		id: z.string().min(1),
 		brief,
+		images: documentImages.default([]),
 		handOffs: z.array(z.object({
 			id: z.string().min(1),
 			workstation: named$1,
@@ -1769,10 +2110,14 @@ const taskStartFields = {
 	*/
 	repositories: workspaceRepositories.default([])
 };
-/** A question an Agent asked the Owner mid-Task, and the Owner's reply, if they gave one. */
+/**
+* A question an Agent asked the Owner mid-Task, and the Owner's reply, if they gave one, with how
+* many images it came with (#186): they went only to the Session it resumed.
+*/
 const helpExchange = z.object({
 	question: helpQuestion,
-	reply: verdictText.nullable()
+	reply: verdictText.nullable(),
+	replyImages: z.number().int().nonnegative().max(IMAGE_LIMITS.images).default(0)
 });
 /**
 * The attempt a Rework follows at its Workstation (ADR-0003): who made it, how it ended, and why,
@@ -1788,8 +2133,13 @@ const previousAttempt = z.object({
 	status: z.enum([...UNSUCCESSFUL_STATUSES, "accepted"]),
 	/** The Hand-off it delivered, if any (fetched like the Workpiece's); it isn't on the Workpiece. */
 	handOff: z.object({ id: z.string().min(1) }).nullable(),
-	/** The check its Hand-off failed (`rejected`): who judged it, and the annotations. */
+	/**
+	* The check its Hand-off failed (`rejected`): who judged it, and the annotations; the images
+	* beside them, the Node fetches by its id (`nodeAnnotationsPath`). (A Session kept in an outbox
+	* from protocol 24 or before names no check, and gets none.)
+	*/
 	check: z.object({
+		id: checkId$1.nullable().default(null),
 		inspector: named$1,
 		annotations
 	}).nullable(),
@@ -1801,16 +2151,39 @@ const previousAttempt = z.object({
 /**
 * A Verdict the Owner gave on a Ticket of the Workpiece's Pipeline Run (spec story 37), which every
 * Agent working on the Workpiece after it is told of: the Ticket (T-n, raised at a Workstation),
-* and the Verdict with what the Owner wrote into it.
+* and the Verdict with what the Owner wrote into it and the images beside those words, each named by
+* its key in the image store, which the Node reads through addresses it fetches for them
+* (`nodeVerdictsPath`).
 */
 const workpieceVerdict = z.object({
 	ticket: z.object({
 		number: z.number().int().positive(),
 		workstation: named$1
 	}),
-	verdict
+	verdict,
+	/**
+	* Whether it routed the Workpiece to the Task this Session works on (#183): the reworking Task
+	* after a Send back or a Rework with guidance, the next station's after an Approve. Its images
+	* come inside that Task's first prompt, besides as files; every Agent after it gets them as files
+	* only. (A Session kept in an outbox from protocol 24 or before is routed by none.)
+	*/
+	routedHere: z.boolean().default(false)
 });
 /**
+* Where the Node fetches addresses to read the images of the Owner's Verdicts on the Workpiece the
+* Task `task` it holds works on (#183), which the message starting its work names by key: GET,
+* answered `fetchedVerdicts`.
+*/
+function nodeVerdictsPath(task) {
+	return `${NODE_TASKS_PATH}/${encodeURIComponent(task)}/verdicts`;
+}
+/**
+* The images of the Owner's latest Verdicts on a Workpiece (the `MAX_WORKPIECE_VERDICTS` a Session
+* is told of) as the Node fetches them: each with an address signed for the Task that fetched it,
+* as a brief's are. Their words are in the message starting the Session.
+*/
+const fetchedVerdicts = z.object({ images: z.array(addressedImage).max(IMAGE_LIMITS.images * 20) });
+/**
 * Start a Session for a Workstation Task, in a fresh Workspace (ADR-0002): everything the Node
 * needs to run it. In its `work` role, `agent` works on the Workpiece at the Task's Workstation and
 * hands off: it is told which attempt this is, what went wrong with the attempt before it if it is
@@ -1832,7 +2205,9 @@ const taskStartMessage = z.discriminatedUnion("role", [z.object({
 	previous: previousAttempt.nullable(),
 	/**
 	* The Owner's Verdicts on the Workpiece so far (the latest `MAX_WORKPIECE_VERDICTS`), in the
-	* order given: the guidance, notes and replies they carry reach every Agent after them.
+	* order given: the guidance, notes and replies they carry reach every Agent after them, and so
+	* do the images beside a guidance or a note, inside the first prompt of the Task one routed the
+	* Workpiece to (`routedHere`), as files to every other.
 	*/
 	verdicts: z.array(workpieceVerdict).max(20),
 	/**
@@ -1879,14 +2254,17 @@ const taskCancelMessage = inRole({
 * Agent binds as the reply was sent (#120), which the Node lays out anew for the resumed segment (a
 * copy it lacks installed first). The Node reports the resumed segment's start (`task-started`), or
 * the Task's end if the Session can't be resumed. (A reply kept in an outbox from protocol 21 or
-* before names no Skills: its segment gets those the Session had.)
+* before names no Skills: its segment gets those the Session had.) A reply with images (#186) names
+* them (`handed`): the Platform handed them to the Node before (`handed-image`), and the Node writes
+* them into the Session's Workspace, inside the prompt that resumes it.
 */
 const taskResumeMessage = z.object({
 	kind: z.literal("task-resume"),
 	...reliableEnvelope,
 	taskId: taskId$1,
 	reply: verdictText,
-	skills: sessionBindings.optional()
+	skills: sessionBindings.optional(),
+	handed: handedImages.optional()
 });
 /**
 * Where an Agent's chat Workspace is made as for (its place, spec story 71), for its instructions:
@@ -1904,12 +2282,12 @@ const chatSayPlace = z.discriminatedUnion("kind", [z.object({
 	to: named$1
 })]).nullable();
 /**
-* The Owner said `message` in turn `turn` of a chat with `agent`, its next prompt. The first turn
-* opens the chat's Session in a fresh Workspace with `repositories` checked out (made as for the
-* Agent's `place`), given the Agent's instructions and nothing of any Workpiece, on its model, with
-* no Factory MCP; each later turn resumes that Session in the same Workspace, with the instructions
-* it started with, whatever `agent` says now. The Node reports the turn's start
-* (`chat-turn-started`) and end (`chat-turn-ended`).
+* The Owner said `message` in turn `turn` of a chat with `agent`, its next prompt, with the images
+* it came with, if any (`handed`). The first turn opens the chat's Session in a fresh Workspace
+* with `repositories` checked out (made as for the Agent's `place`), given the Agent's instructions
+* and nothing of any Workpiece, on its model, with no Factory MCP; each later turn resumes that
+* Session in the same Workspace, with the instructions it started with, whatever `agent` says now.
+* The Node reports the turn's start (`chat-turn-started`) and end (`chat-turn-ended`).
 */
 const chatSayMessage = z.object({
 	kind: z.literal("chat-say"),
@@ -1928,7 +2306,13 @@ const chatSayMessage = z.object({
 	}),
 	place: chatSayPlace,
 	repositories: workspaceRepositories,
-	message: chatMessage
+	message: chatMessage,
+	/**
+	* The images the message came with (#187), which the Platform handed the Node before
+	* (`handed-image`, for this turn): the turn writes them into whatever Workspace it opens or
+	* resumes, and its prompt carries them.
+	*/
+	handed: handedImages.optional()
 });
 /**
 * The Node's Tasks and chats someone is watching now: relay their live activity (`session-events`,
@@ -2144,6 +2528,8 @@ const named = z.object({
 /** What every Workstation is besides who staffs it (`workstationSummary`). */
 const station = named.extend({
 	attemptBudget,
+	/** Its time limit in minutes (#174): the default in an event recorded before it could be set. */
+	timeLimitMinutes: timeLimitMinutes.default(TIME_LIMIT.default),
 	along,
 	/** Its Workspace policy (#90): the repositories each fresh Workspace there gets checked out. */
 	repositories: workspaceRepositories,
@@ -2157,8 +2543,8 @@ const emptyWorkstation = station.extend({
 /**
 * A Workstation: who staffs it, its Operator (an Agent, or the Owner at a Human Workstation, which
 * has no Agent), or no one yet (an empty Workstation, which has none either); how many attempts it
-* gets at a Workpiece in a round (a Human one, one), where it stands along its line, its Workspace
-* policy and its revision.
+* gets at a Workpiece in a round (a Human one, one) and its time limit (a Human one's unused),
+* where it stands along its line, its Workspace policy and its revision.
 */
 const workstationSummary = z.discriminatedUnion("operator", [
 	station.extend({
@@ -2222,7 +2608,7 @@ const agentRestoredEvent = z.object({
 });
 /** A Factory, Workshop or Pipeline as it stands: where, in what holds it, and its revision. */
 const placed = named.extend({
-	at: spot,
+	at: spot$1,
 	revision
 });
 /**
@@ -2262,7 +2648,7 @@ const definitionMovedEvent = z.object({
 	kind: z.literal("definition-moved"),
 	definition: movableDefinition,
 	id: z.string().min(1),
-	at: spot,
+	at: spot$1,
 	revision
 });
 /**
@@ -2460,7 +2846,9 @@ const checkGateRepositoriesSetEvent = z.object({
 * The Owner staffed Workstation `workstationId` of Pipeline `pipelineId` (#63): with `agent`
 * (`operator` "agent"), with themselves as its Human (`operator` "human", no Agent), or with no one
 * (`operator` null, no Agent), freeing whoever staffed it before. `attemptBudget` is how many
-* attempts it gets now (a Human Workstation one), `revision` its revision now.
+* attempts it gets now (a Human Workstation one), `timeLimitMinutes` its time limit now (a Human
+* Workstation's the default, unused; the default in an event recorded before it could be set),
+* `revision` its revision now.
 */
 const workstationStaffedEvent = z.object({
 	kind: z.literal("workstation-staffed"),
@@ -2469,6 +2857,7 @@ const workstationStaffedEvent = z.object({
 	operator: operatorKind.nullable(),
 	agent: named.nullable(),
 	attemptBudget,
+	timeLimitMinutes: timeLimitMinutes.default(TIME_LIMIT.default),
 	revision
 });
 /**
@@ -2484,6 +2873,19 @@ const attemptBudgetChangedEvent = z.object({
 	revision
 });
 /**
+* The Owner set how long a Task at Agent Workstation `workstationId` of Pipeline `pipelineId` may
+* be at work in one segment of its Session (#174), in minutes, from its next segment on: a segment
+* timed already keeps the limit it started with.
+*/
+const timeLimitChangedEvent = z.object({
+	kind: z.literal("time-limit-changed"),
+	pipelineId: z.string().min(1),
+	workstationId: z.string().min(1),
+	timeLimitMinutes,
+	/** The Workstation's revision now. */
+	revision
+});
+/**
 * The Owner set the Workspace policy of Workstation `workstationId` of Pipeline `pipelineId`
 * (#90): each fresh Workspace there gets `repositories` checked out, in this order, each in its
 * folder, from its next Task on.
@@ -2508,9 +2910,15 @@ const runDispatchedEvent = z.object({
 	runId,
 	number: z.number().int().positive(),
 	pipeline: named,
+	/**
+	* Its Workpiece: the brief, and the images it carries beside its words, each by its key in the
+	* image store, never an address to read it at (they expire; the ledger is kept). (Dispatched with
+	* protocol 24 or before, it has none.)
+	*/
 	workpiece: z.object({
 		id: z.string().min(1),
-		brief
+		brief,
+		images: documentImages.default([])
 	}),
 	scheduleId: z.string().min(1).nullable().default(null)
 });
@@ -2610,7 +3018,10 @@ const checkStartedEvent = z.object({
 	taskId,
 	checkId
 });
-/** The Inspector judged the Hand-off: passed, or failed with annotations. */
+/**
+* The Inspector judged the Hand-off: passed, or failed with annotations and the images beside them,
+* each by its key in the image store (none in an event from before #184).
+*/
 const checkJudgedEvent = z.object({
 	kind: z.literal("check-judged"),
 	runId,
@@ -2994,6 +3405,7 @@ const ledgerEvent = z.discriminatedUnion("kind", [
 	checkGateRemovedEvent,
 	checkGateRepositoriesSetEvent,
 	attemptBudgetChangedEvent,
+	timeLimitChangedEvent,
 	workstationRepositoriesSetEvent,
 	scheduleAddedEvent,
 	scheduleEditedEvent,
@@ -3063,6 +3475,373 @@ const PASSWORD_LIMITS = {
 	max: 128
 };
 `${PASSWORD_LIMITS.long}${PASSWORD_LIMITS.short}`;
+/**
+* A Showroom's title as the Owner writes it (spec story 31): words of their own, trimmed, never
+* filled in from their name (ADR-0021 rule 3). Empty until they write one; opening needs one.
+*/
+const showroomTitle = z.string().trim().max({
+	/** Characters of its title. */
+	title: 80,
+	/**
+	* How many Visitors watch it at once (spec story 53), so that one link going viral can't slow
+	* every Owner's factory: the next is told it's full (`showroomMessage`). A browser signed in as
+	* its own Owner isn't counted, the hidden frame that takes its card's picture among them.
+	*/
+	visitors: 200,
+	/**
+	* The least time between two views a Showroom's feed builds and sends (spec story 54): at most
+	* twice a second, however busy the factory.
+	*/
+	viewIntervalMs: 500,
+	/**
+	* How long after its Run ended a Workpiece is still in the view, done or scrapped: long enough
+	* for the World to play it leaving the line, after the courier robot carried back the Verdict
+	* that ended it (spec story 5).
+	*/
+	justEndedMs: 6e4
+}.title);
+/**
+* The operating systems a Visitor may read on a Node's tower (spec story 49), by family only: the
+* name a Node gives for its system, its release and its machine's architecture stay with the Owner
+* (ADR-0021 rule 3).
+*/
+const SHOWROOM_SYSTEMS = [
+	"macos",
+	"linux",
+	"windows",
+	"other"
+];
+/** A place on the island or in what holds it, as the World draws it (ADR-0015). */
+const spot = z.strictObject({
+	x: z.number(),
+	z: z.number()
+});
+/** A thing by its id alone. */
+const ref = z.strictObject({ id: z.string() });
+/**
+* A Workstation on a chosen line.
+* - What: its id, its name, how far along its line it stands, and who staffs it: an Agent (by id),
+*   the Owner (a Human), or no one yet.
+* - From: `workstation` (id, name, along, operator, agent_id).
+* - Why: the World draws it, labelled with its name, and its Operator's figure (rule 1). Never its
+*   repositories (rule 2) nor its attempt budget, which nothing draws.
+*/
+const showroomWorkstation = z.union([
+	z.strictObject({
+		id: z.string(),
+		name: z.string(),
+		along: z.number(),
+		operator: z.literal("agent"),
+		agent: ref
+	}),
+	z.strictObject({
+		id: z.string(),
+		name: z.string(),
+		along: z.number(),
+		operator: z.literal("human"),
+		agent: z.null()
+	}),
+	z.strictObject({
+		id: z.string(),
+		name: z.string(),
+		along: z.number(),
+		operator: z.null(),
+		agent: z.null()
+	})
+]);
+/**
+* A Belt on a chosen line.
+* - What: its id, the Workstations it joins, whether a Check gate stands on it, and its
+*   Inspector's id.
+* - From: `belt` (id, from_workstation_id, to_workstation_id, gated, inspector_id).
+* - Why: the World draws the Belt, its gate and the Inspector's figure there (rule 1). Never its
+*   criteria or repositories (rule 2): whether a gate stands is `gated`, never read off criteria.
+*/
+const showroomBelt = z.strictObject({
+	id: z.string(),
+	fromWorkstationId: z.string(),
+	toWorkstationId: z.string(),
+	gated: z.boolean(),
+	inspector: ref.nullable()
+});
+/**
+* One of a Pipeline's Intakes, in the order they were made: its Dispatch, or a Schedule standing
+* there, paused or not.
+* - What: its kind, and a Schedule's whether it is paused.
+* - From: `intake` (kind) and `schedule` (paused), those not removed (`retirement_id`).
+* - Why: a scheduled Intake's hopper is an hourglass, its sand running while a Schedule on a line
+*   not paused runs (rule 1). Never a Schedule's cadence, timezone, brief or overlap (rule 2), nor
+*   an Intake's id, a handle to release anything with (rule 4).
+*/
+const showroomIntake = z.discriminatedUnion("kind", [z.strictObject({ kind: z.literal("dispatch") }), z.strictObject({
+	kind: z.literal("schedule"),
+	paused: z.boolean()
+})]);
+/**
+* A Pipeline in a chosen Workshop.
+* - What: its id, its name, where its Intake stands, whether the Owner paused it, its Intakes,
+*   its Workstations and Belts.
+* - From: `pipeline` (id, name, at_x, at_z, paused).
+* - Why: the World draws the line where it stands, flagged while paused, and the breadcrumb names
+*   it (rule 1).
+*/
+const showroomPipeline = z.strictObject({
+	id: z.string(),
+	name: z.string(),
+	at: spot,
+	paused: z.boolean(),
+	intakes: z.array(showroomIntake),
+	workstations: z.array(showroomWorkstation),
+	belts: z.array(showroomBelt)
+});
+/**
+* A Workshop in a chosen Factory.
+* - What: its id, its name, where it stands in its Factory, its Pipelines.
+* - From: `workshop` (id, name, at_x, at_z).
+* - Why: the World draws it with its plate (rule 1).
+*/
+const showroomWorkshop = z.strictObject({
+	id: z.string(),
+	name: z.string(),
+	at: spot,
+	pipelines: z.array(showroomPipeline)
+});
+/**
+* A chosen Factory, oldest first.
+* - What: its id, its name, where it stands on the island, its Workshops.
+* - From: `factory` (id, name, at_x, at_z), only those the Owner chose (`showroom.factory_ids`)
+*   and still standing.
+* - Why: the World draws it with its sign (rule 1); no other Factory exists for a Visitor (rule 5).
+*/
+const showroomFactory = z.strictObject({
+	id: z.string(),
+	name: z.string(),
+	at: spot,
+	workshops: z.array(showroomWorkshop)
+});
+/**
+* An Agent with a place in a chosen Factory, in the order they were hired.
+* - What: its id, its name, its Runtime and its Node's id.
+* - From: `agent` (id, name, runtime, node_id), only the Agents staffing a Workstation or
+*   inspecting a Belt on a chosen line.
+* - Why: the World draws its figure in its Runtime's silhouette, and hover words name it (rule 1);
+*   its Node's id says which tower's status puts it to sleep. Never its instructions, model or
+*   Skills (rule 2); no Agent without a place (rule 5).
+*/
+const showroomAgent = z.strictObject({
+	id: z.string(),
+	name: z.string(),
+	runtime: z.enum(RUNTIME_IDS),
+	node: ref
+});
+/**
+* One of the Owner's Nodes that isn't revoked, in the order they joined.
+* - What: its id, whether it is online, and its system's family (`SHOWROOM_SYSTEMS`).
+* - From: `node` (id, status, os's platform), those with no revoked_at.
+* - Why: the World draws a tower for it in the home corner, its beacon lit while it is online, and
+*   an Agent of an offline Node asleep (rule 1); its board shows its system in place of its name.
+*   Never its name, its system's release or architecture, nor its Runtimes or their versions
+*   (rule 3).
+*/
+const showroomNode = z.strictObject({
+	id: z.string(),
+	status: z.enum(["online", "offline"]),
+	system: z.enum(SHOWROOM_SYSTEMS)
+});
+/**
+* The island's home corner.
+* - What: where the Desk and the Node towers beside it stand.
+* - From: `island` (home_x, home_z), or where every new island has it.
+* - Why: the World draws the Desk and the towers there (rule 1); it is structure, read by no one
+*   opening anything.
+*/
+const showroomIsland = z.strictObject({ home: spot });
+/**
+* A Workstation Task of a Run in `runs`, in the order they were queued.
+* - What: its id, its status, when it was queued, its Agent's id (none at a Human Workstation),
+*   its Workstation's id, and its Hand-off's checks' statuses in order (a check's status holds its
+*   outcome: passed, failed, or no judgement).
+* - From: `workstation_task` (id, status, queued_at, agent_id, workstation_id) and `check`
+*   (status).
+* - Why: where its Workpiece is, how it looks (warm once a Task was accepted, the "ok" mark once
+*   a check passed or an Audit approved it) and what lights a Workstation or a Check gate are
+*   drawn from them, and when it was queued lines Workpieces up at a place (rule 1). Never its
+*   brief, Hand-off, failure, attempt or cause, nor a check's criteria, annotations or reason
+*   (rule 2).
+*/
+const showroomTask = z.strictObject({
+	id: z.string(),
+	status: z.enum(WORKSTATION_TASK_STATUSES),
+	queuedAt: z.string(),
+	agent: ref.nullable(),
+	workstation: ref,
+	checks: z.array(z.strictObject({ status: z.enum(CHECK_STATUSES) }))
+});
+/**
+* Where a Workpiece holds on its paused line (the protocol's `workpieceHold`), drawn there: at its
+* Intake; after Task `taskId`'s Hand-off, its check passed or its attempt; or, with a Verdict to
+* apply, at the Workstation of the fresh round it sends the Workpiece to, or past Task `taskId`'s.
+* Never the Ticket whose Verdict it is.
+*/
+const showroomHold = z.union([
+	z.strictObject({ at: z.literal("intake") }),
+	z.strictObject({
+		at: z.enum([
+			"hand-off",
+			"check-passed",
+			"rework"
+		]),
+		taskId: z.string()
+	}),
+	z.strictObject({
+		at: z.literal("verdict"),
+		taskId: z.string(),
+		workstationId: z.string().nullable()
+	})
+]);
+/**
+* A Pipeline Run on a chosen line, in progress or just ended (done or scrapped within
+* `SHOWROOM_LIMITS.justEndedMs`), in the order they were dispatched: Workpieces that came at the
+* same moment line up in that order.
+* - What: its id, its status, its Pipeline's id, when it was dispatched, where its Workpiece holds
+*   on its paused line (null while it doesn't, `showroomHold`), and its Tasks (`showroomTask`).
+* - From: `pipeline_run` (id, status, pipeline_id, dispatched_at, held; completed_at and
+*   scrapped_at, for how long ago it ended).
+* - Why: its Workpiece rides the line, waits at Check gates, goes back for Rework and leaves it,
+*   done into the bin or as Scrap (rule 1). Never its Workpiece's brief, its failure or its
+*   number (rule 2); a Run that failed leaves the floor at once, as on the Owner's.
+*/
+const showroomRun = z.strictObject({
+	id: z.string(),
+	status: z.enum([
+		"in-progress",
+		"completed",
+		"scrapped"
+	]),
+	pipeline: ref,
+	dispatchedAt: z.string(),
+	held: showroomHold.nullable(),
+	tasks: z.array(showroomTask)
+});
+/**
+* An open Ticket raised in a chosen Factory, oldest first.
+* - What: its id, whether the courier robot carries it to the Desk (an Audit), its Task's and Run's
+*   ids, and where it was raised: its Pipeline and Workstation.
+* - From: `ticket` (id, category, task_id, run_id, workstation_id; those open) and its Run's
+*   `pipeline_id`.
+* - Why: it flies to the Desk from where it was raised, or the courier robot fetches it, and stacks
+*   there, while its Workpiece waits for the Owner (rule 1). Never its number, title, reason,
+*   question or Verdict, nor which kind it is beyond whether it is carried (rule 2); none raised
+*   in a Factory not chosen (rule 5).
+*/
+const showroomTicket = z.strictObject({
+	id: z.string(),
+	carried: z.boolean(),
+	taskId: z.string(),
+	run: ref,
+	from: z.strictObject({
+		pipeline: ref,
+		workstation: ref
+	})
+});
+/**
+* A moment the World marks once, as it arrives live: a Task just accepted (it plays just finished
+* at its Workstation), a check just judged (its gate plays the stamp of its outcome), or a Verdict
+* just given on an Audit the courier robot carried (the robot carries the paper back, inked with
+* where it sends the Workpiece: on, back for Rework, or to its end).
+* - What: its kind, and the Task's or the Ticket's id; a check's outcome; a Verdict's ink
+*   (`VERDICT_INKS`).
+* - From: the Owner's ledger since the view before (`task-accepted`, `check-judged`,
+*   `ticket-ruled`: their kind, Task, Ticket, outcome and Verdict's kind alone), of the Tasks of
+*   `runs` and the carried Audits on their lines.
+* - Why: each plays once on the floor (rule 1). Never a check's annotations, nor what a Verdict
+*   says, its kind beyond where it sends the Workpiece, or who gave it (rules 2 and 3).
+*/
+const showroomMoment = z.discriminatedUnion("kind", [
+	z.strictObject({
+		kind: z.literal("task-accepted"),
+		taskId: z.string()
+	}),
+	z.strictObject({
+		kind: z.literal("check-judged"),
+		taskId: z.string(),
+		outcome: z.enum(["passed", "failed"])
+	}),
+	z.strictObject({
+		kind: z.literal("verdict"),
+		ticketId: z.string(),
+		ink: z.enum(VERDICT_INK_KINDS)
+	})
+]);
+/**
+* What an Agent at work on a Task under way is doing, by the Task's id (a check's Inspector's,
+* while its Hand-off is checked).
+* - What: thinking or working; an idle one isn't listed.
+* - From: the pulses Nodes send the Platform (live activity, in memory), for the Tasks in `runs`.
+* - Why: the light of thinking and working is drawn (rule 1). Never the tool it uses, nor what it
+*   says (rule 2); a chat's pulse never, since a chat is no work of the line (ADR-0021).
+*/
+const showroomActivity = z.strictObject({ state: z.enum(["thinking", "working"]) });
+/**
+* The caption's figures (spec #146, "The caption's figures"), counting only the chosen Factories'
+* in-service lines, as the Owner signed the caption off in the gallery (#159).
+* Whether the factory runs now, and how many Workstations and Check gates are at work, are not
+* among them: the page reads both off what its World lights from the view (the World's
+* `atWork`), the one rule for the caption, the World and the card.
+* - What: how many Workpieces finished, and how many Workstation Tasks were queued as Rework, in
+*   the last day (`SHOWROOM_FIGURES_SPAN_MS`); and when the World last lit work, as the records
+*   show it: at a time, or never.
+* - From: `workstation_task` (cause, queued_at, started_at, usage_recorded_at), `check`
+*   (started_at, ended_at), `hand_off` (created_at), `ticket` (raised_at, ruled_at,
+*   withdrawn_at) and `pipeline_run` (status, completed_at), counted, never listed
+*   (`packages/platform/src/showroom/figures.ts`).
+* - Why: they tell how much the factory drawn on the floor works, so that a dark island reads as
+*   resting, not broken (rule 1: the lights of work, counted). Never which Workpiece, what it was
+*   about or why a Rework was needed (rule 2); nothing of an unchosen Factory (rule 5).
+*/
+const showroomFigures = z.strictObject({
+	finished: z.number().int().nonnegative(),
+	rework: z.number().int().nonnegative(),
+	lastAtWork: z.discriminatedUnion("kind", [z.strictObject({
+		kind: z.literal("ago"),
+		at: z.iso.datetime()
+	}), z.strictObject({ kind: z.literal("never") })])
+});
+/**
+* What a Visitor receives of a Showroom (ADR-0021): the whitelist. Each item says what it is,
+* where the Platform takes it from and why the rules allow it.
+*/
+const showroomView = z.strictObject({
+	/**
+	* The Showroom's title. From `showroom.title`. Why: the Owner wrote it for Visitors to read, in
+	* words of their own (rule 3: never filled in from their name).
+	*/
+	title: showroomTitle,
+	/** The caption's figures (`showroomFigures`). */
+	figures: showroomFigures,
+	factories: z.array(showroomFactory),
+	agents: z.array(showroomAgent),
+	nodes: z.array(showroomNode),
+	island: showroomIsland,
+	runs: z.array(showroomRun),
+	tickets: z.array(showroomTicket),
+	activity: z.record(z.string(), showroomActivity),
+	/** The moments since the view before, oldest first (`showroomMoment`). */
+	moments: z.array(showroomMoment)
+});
+z.discriminatedUnion("kind", [
+	z.strictObject({
+		kind: z.literal("view"),
+		live: z.boolean(),
+		view: showroomView
+	}),
+	z.strictObject({ kind: z.literal("closed") }),
+	z.strictObject({
+		kind: z.literal("full"),
+		title: z.string(),
+		figures: showroomFigures.nullable()
+	})
+]);
 [
 	"password",
 	"github",
@@ -3086,18 +3865,18 @@ function jsonIn(text) {
 	}
 }
 /** A file being written, under the name it gets once it is whole. */
-const PARTIAL = ".tmp";
+const PARTIAL$1 = ".tmp";
 /**
-* Writes `text` to `path`, readable by this user only, in one step: aside first, then renamed over
-* it, so a crash leaves the whole file (old or new) and never part of one.
+* Writes `text` (or bytes) to `path`, readable by this user only, in one step: aside first, then
+* renamed over it, so a crash leaves the whole file (old or new) and never part of one.
 */
 async function writeAtomically(path, text) {
-	await writeFile(`${path}${PARTIAL}`, text, { mode: 384 });
-	await rename(`${path}${PARTIAL}`, path);
+	await writeFile(`${path}${PARTIAL$1}`, text, { mode: 384 });
+	await rename(`${path}${PARTIAL$1}`, path);
 }
 /** Whether `file` was left half-written by a crash during `writeAtomically`. */
 function isPartial(file) {
-	return file.endsWith(PARTIAL);
+	return file.endsWith(PARTIAL$1);
 }
 /** Items can hold anything; their files are named by a hash. */
 function fileOf(item) {
@@ -3130,10 +3909,12 @@ async function openFileSet(dir) {
 /**
 * Where a Node keeps its own files: its credential (`node.json`) and its outbox. The
 * `MOONMILL_NODE_HOME` environment variable moves it, for example to run two Nodes on one
-* machine.
+* machine; a relative one is taken from the folder the daemon starts in, since the paths an
+* Agent's instructions give under it must be absolute.
 */
 function defaultStateDir(env = process.env) {
-	return env["MOONMILL_NODE_HOME"] ?? join(homedir(), ".moonmill", "node");
+	const home = env["MOONMILL_NODE_HOME"];
+	return home === void 0 ? join(homedir(), ".moonmill", "node") : resolve(home);
 }
 /** What a Node got when it joined: who it is, where its Platform is, and how to prove it. */
 const nodeCredential = z.object({
@@ -3587,6 +4368,8 @@ var UnreadableMessageError = class extends Error {
 	name = "UnreadableMessageError";
 };
 const SUFFIX = ".json";
+/** The folder of the outbox the images its messages name are kept in. */
+const IMAGES = "images";
 /** The file the message at `place` in line is kept in: their names keep them in line. */
 function fileInLine(place) {
 	return `${String(place).padStart(12, "0")}${SUFFIX}`;
@@ -3598,6 +4381,7 @@ function placeOf(file) {
 /** The kind a message this daemon can't read says it is, if it says. */
 const sayingItsKind = z.object({ kind: z.string() });
 async function openOutbox(dir) {
+	const imagesDir = join(dir, IMAGES);
 	await mkdir(dir, {
 		recursive: true,
 		mode: 448
@@ -3606,6 +4390,7 @@ async function openOutbox(dir) {
 	const discarded = [];
 	let next = 0;
 	for (const file of (await readdir(dir)).toSorted()) {
+		if (file === IMAGES) continue;
 		if (!file.endsWith(SUFFIX)) {
 			await rm(join(dir, file), { force: true });
 			continue;
@@ -3629,26 +4414,56 @@ async function openOutbox(dir) {
 		});
 		next = Math.max(next, placeOf(file) + 1);
 	}
+	/** How many messages on their way in name each image, by its key. */
+	const adding = /* @__PURE__ */ new Map();
+	/** The keys of the images a kept message names, or one on its way in. */
+	const named = () => /* @__PURE__ */ new Set([...adding.keys(), ...[...kept.values()].flatMap(({ message }) => imagesNamedBy(message).map(({ key }) => key))]);
+	/** Deletes every image no kept message names: one acknowledged, discarded or half-written. */
+	const sweepImages = async () => {
+		const needed = named();
+		for (const file of await readdir(imagesDir).catch(() => [])) if (!needed.has(file)) await rm(join(imagesDir, file), { force: true });
+	};
+	await sweepImages();
 	return {
 		discarded,
-		async add(message) {
+		async add(message, images = []) {
 			const readable = nodeMessage.safeParse(message);
 			if (!readable.success) throw new UnreadableMessageError(`Not a message the Platform can read: ${z.prettifyError(readable.error)}`);
-			const file = fileInLine(next++);
-			await writeAtomically(join(dir, file), JSON.stringify(message));
-			kept.set(message.id, {
-				file,
-				message
-			});
+			const given = new Map(images.map((image) => [image.key, image.bytes]));
+			const keys = imagesNamedBy(message).map(({ key }) => key);
+			for (const key of keys) if (!given.has(key)) throw new UnreadableMessageError(`The image ${key} it names isn't given with it`);
+			for (const key of keys) adding.set(key, (adding.get(key) ?? 0) + 1);
+			try {
+				if (keys.length > 0) await mkdir(imagesDir, {
+					recursive: true,
+					mode: 448
+				});
+				for (const key of keys) await writeAtomically(join(imagesDir, imageKey.parse(key)), given.get(key) ?? "");
+				const file = fileInLine(next++);
+				await writeAtomically(join(dir, file), JSON.stringify(message));
+				kept.set(message.id, {
+					file,
+					message
+				});
+			} finally {
+				for (const key of keys) {
+					const count = (adding.get(key) ?? 1) - 1;
+					if (count > 0) adding.set(key, count);
+					else adding.delete(key);
+				}
+			}
 		},
 		async remove(id) {
 			const entry = kept.get(id);
 			if (!entry) return null;
 			kept.delete(id);
 			await rm(join(dir, entry.file), { force: true });
+			const needed = named();
+			for (const { key } of imagesNamedBy(entry.message)) if (!needed.has(key)) await rm(join(imagesDir, key), { force: true });
 			return entry.message;
 		},
-		pending: () => [...kept.values()].map((entry) => entry.message)
+		pending: () => [...kept.values()].map((entry) => entry.message),
+		image: async (key) => new Uint8Array(await readFile(join(imagesDir, imageKey.parse(key))))
 	};
 }
 //#endregion
@@ -3659,7 +4474,7 @@ async function openOutbox(dir) {
 * copy included): `from` is gone either way.
 */
 async function fileCopy(from, folder) {
-	if (!await isThere$1(folder)) {
+	if (!await isThere$2(folder)) {
 		await mkdir(dirname(folder), {
 			recursive: true,
 			mode: 448
@@ -3669,7 +4484,7 @@ async function fileCopy(from, folder) {
 			await rename(from, folder);
 			filed = true;
 		} catch (error) {
-			if (!(error instanceof Error && "code" in error && await isThere$1(folder))) throw error;
+			if (!(error instanceof Error && "code" in error && await isThere$2(folder))) throw error;
 		}
 		if (filed) {
 			await sealCopy(folder);
@@ -3683,7 +4498,7 @@ async function fileCopy(from, folder) {
 * there to take, since a check's copy may go (dropped, or taken over just now) at any time.
 */
 async function takeCopyOver(from, folder) {
-	if (!await isThere$1(from)) return false;
+	if (!await isThere$2(from)) return false;
 	await mkdir(dirname(folder), {
 		recursive: true,
 		mode: 448
@@ -3723,7 +4538,7 @@ async function unseal(folder) {
 	for (const name of await readdir(folder)) await unseal(join(folder, name));
 }
 /** Whether a copy stands at `folder`: a folder of its own, not a link to one. */
-async function isThere$1(folder) {
+async function isThere$2(folder) {
 	return (await lstat(folder).catch(() => null))?.isDirectory() ?? false;
 }
 /** The names in folder `dir`, sorted, none when it isn't there. */
@@ -4082,22 +4897,242 @@ async function osName(platform) {
 	return platform === "win32" ? version() : null;
 }
 //#endregion
-//#region src/skill-acceptance.ts
-/** The file at the top of a Skill's folder that names and describes it. */
-const SKILL_FILE = "SKILL.md";
-/** How big a Skill's folder may be: its files' bytes added up, and how many files it holds. */
-const SKILL_FOLDER_LIMITS = {
-	bytes: 52428800,
-	files: 5e3
+//#region src/workspace-images.ts
+/** The file extension of each image type. */
+const EXTENSIONS = {
+	"image/png": "png",
+	"image/jpeg": "jpg",
+	"image/gif": "gif",
+	"image/webp": "webp"
 };
 /**
-* Accepts `folder` as a Skill, or says why not, in the Owner's words. A `.git` at its top (a
-* clone's history, which differs on every machine) is deleted first: it isn't the Skill's.
+* Writes a document's `images` into `workspace` beside it, in order, reading image `index`'s bytes
+* with `bytesOf(index)` as it is written. Returns them as written, for what the Agent is told.
 */
-async function acceptSkill(folder) {
-	await rm(join(folder, ".git"), {
+async function writeImages(workspace, { folder, stem }, images, bytesOf) {
+	if (images.length > 0) await mkdir(join(workspace, folder), {
 		recursive: true,
-		force: true
+		mode: 448
+	});
+	const written = [];
+	for (const [index, image] of images.entries()) {
+		const file = `${stem}-${index + 1}.${EXTENSIONS[image.mimeType]}`;
+		await writeFile(join(workspace, folder, file), await bytesOf(index), { mode: 384 });
+		written.push({
+			path: posix.join(folder, file),
+			mimeType: image.mimeType,
+			alt: image.alt
+		});
+	}
+	return written;
+}
+/**
+* A document's written images as Markdown, one image link a line, each linked from `folder` of the
+* Workspace, where they are named: `![A chart](1-draft-1.png)` from `workpiece`, and
+* `![A chart](workpiece/1-draft-1.png)` from the root (`""`).
+*/
+function imageLinks(images, folder) {
+	return images.map((image, index) => imageLink(image, index, folder)).join("\n");
+}
+/**
+* One of a document's images as a Markdown image link from `folder` of the Workspace, image `index`
+* of the document: `![A chart](workpiece/1-draft-1.png)` from the root (`""`).
+*/
+function imageLink({ path, alt }, index, folder) {
+	return `![${alt ?? `Image ${index + 1}`}](${posix.relative(folder, path)})`;
+}
+/**
+* What lies beside a document with `count` images, as the instructions' line on it ends: ", with
+* its image beside it", ", with its 3 images beside it", or nothing.
+*/
+function besideIt(count) {
+	if (count === 0) return "";
+	return `, with its ${count === 1 ? "image" : `${count} images`} beside it`;
+}
+/**
+* The image at `path` in `workspace` (from its root, or absolute), as it is now, read whole only
+* when it is within `IMAGE_LIMITS.bytes`: its size is what was read, never what a look before said,
+* so a file growing meanwhile is refused all the same.
+*/
+async function readWorkspaceImage(workspace, path) {
+	/** Whether the Workspace went, or only the file: what a missing file means. */
+	const missing = async () => await isThere$1(workspace) ? { kind: "absent" } : { kind: "gone" };
+	let file;
+	try {
+		file = await realpath(resolve(workspace, path));
+	} catch (error) {
+		if (!isMissing$1(error)) throw error;
+		return missing();
+	}
+	const fromRoot = relative(await realpath(workspace), file);
+	if (fromRoot.startsWith("..") || isAbsolute(fromRoot)) return { kind: "outside" };
+	const bytes = await readAtMost(file, IMAGE_LIMITS.bytes + 1).catch((error) => {
+		if (isMissing$1(error)) return null;
+		throw error;
+	});
+	if (bytes === null) return missing();
+	if (bytes.length > IMAGE_LIMITS.bytes) return { kind: "too-large" };
+	const mimeType = imageTypeOf(bytes);
+	return mimeType === null ? { kind: "not-an-image" } : {
+		kind: "image",
+		mimeType,
+		bytes
+	};
+}
+/** The first `most` bytes of file `path`, or all of it when it holds fewer. */
+async function readAtMost(path, most) {
+	const handle = await open(path, "r");
+	try {
+		const bytes = Buffer.alloc(most);
+		let read = 0;
+		while (read < most) {
+			const { bytesRead } = await handle.read(bytes, read, most - read, read);
+			if (bytesRead === 0) break;
+			read += bytesRead;
+		}
+		return bytes.subarray(0, read);
+	} finally {
+		await handle.close();
+	}
+}
+/**
+* The image at `path` in `workspace`, for the Owner, as it is now (`readWorkspaceImage`); `gone`
+* once the Workspace is.
+*/
+async function imageInWorkspace(workspace, path) {
+	const read = await readWorkspaceImage(workspace, path);
+	if (read.kind === "image" || read.kind === "gone") return read;
+	return {
+		kind: "missing",
+		why: read.kind === "absent" ? "the image was deleted from its Workspace" : read.kind === "outside" ? "the image was moved out of its Workspace" : "the image in its Workspace was changed since"
+	};
+}
+/** Whether `folder` is there. */
+async function isThere$1(folder) {
+	try {
+		return (await stat(folder)).isDirectory();
+	} catch (error) {
+		if (isMissing$1(error)) return false;
+		throw error;
+	}
+}
+/** Whether `error` says a file isn't there. */
+function isMissing$1(error) {
+	return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+//#endregion
+//#region src/prompt-images.ts
+const MiB = 1048576;
+/**
+* How much of the Owner's images each Runtime takes inside one prompt. `largest` is measured on
+* the real CLIs (`pnpm probe:runtimes --spend-tokens`, 2026-11-04, #182): Claude Code 2.1.310 (on
+* haiku), Codex 0.164.0 and Kimi Code 2.3.0 (on their own default models) each saw every size the
+* probe tries, up to 10 MiB, the most an image may be (`IMAGE_LIMITS.bytes`), Claude Code's past
+* the 5 MB of base64 per image Anthropic's API takes (docs/research/real-cli-probe.md says what that
+* shows). `count` and `together` are fixed bounds, not measured: 20 images, past which
+* Anthropic's API lowers the pixels it takes of each, and 15 MiB, so that a prompt's images stay
+* well within a request's 32 MB there.
+*/
+const PROMPT_IMAGE_LIMITS = {
+	"claude-code": {
+		largest: 10 * MiB,
+		count: 20,
+		together: 15 * MiB
+	},
+	codex: {
+		largest: 10 * MiB,
+		count: 20,
+		together: 15 * MiB
+	},
+	"kimi-code": {
+		largest: 10 * MiB,
+		count: 20,
+		together: 15 * MiB
+	}
+};
+/**
+* What `prompt` gives a Session of `runtime` in Workspace `cwd`: its words, then a paragraph per
+* group of images naming each, and the images that go inside it, those its Runtime takes
+* (`takesImages`) within `limits`, in order; none when the Runtime `refused` them in this prompt
+* already. Words alone go as they are.
+*/
+async function deliveredPrompt(prompt, how) {
+	if (typeof prompt === "string") return {
+		input: prompt,
+		images: []
+	};
+	const name = RUNTIME_NAMES[how.runtime];
+	const { largest, count, together } = how.limits;
+	const inside = [];
+	let carried = 0;
+	/** Why `image` can't go inside the prompt (`""` for a file it can't read), or null when it can. */
+	const heldBack = async ({ path }) => {
+		if (how.refused) return `as ${name} refused it inside the prompt`;
+		if (!how.takesImages) return `as ${name} takes no images inside a prompt`;
+		const bytes = await sizeOf$1(join(how.cwd, path));
+		if (bytes === null) return "";
+		if (bytes > largest) return `larger than ${name} takes inside a prompt (${sizeWords(largest)})`;
+		if (inside.length >= count) return `past the ${count} images ${name} takes inside one prompt`;
+		if (carried + bytes > together) return `past the ${sizeWords(together)} of images ${name} takes inside one prompt`;
+		carried += bytes;
+		return null;
+	};
+	const paragraphs = [prompt.text];
+	for (const { of, images } of prompt.images) {
+		if (images.length === 0) continue;
+		const lines = [];
+		for (const [index, image] of images.entries()) {
+			const why = await heldBack(image);
+			const link = imageLink(image, index, "");
+			if (why === null) {
+				inside.push({
+					path: join(how.cwd, image.path),
+					mediaType: image.mimeType
+				});
+				lines.push(`- ${link}: with this prompt`);
+			} else lines.push(`- ${link}: a file only${why ? `, ${why}` : ""}: open it to see it`);
+		}
+		const whose = `${of.charAt(0).toUpperCase()}${of.slice(1)}'s`;
+		const which = images.length === 1 ? "image, a file" : `${images.length} images, each a file`;
+		paragraphs.push(`${whose} ${which} in this Workspace:\n\n${lines.join("\n")}`);
+	}
+	return {
+		input: paragraphs.join("\n\n"),
+		images: inside
+	};
+}
+/** How many bytes the file at `path` holds, or null when it can't be read. */
+async function sizeOf$1(path) {
+	try {
+		const found = await stat(path);
+		return found.isFile() ? found.size : null;
+	} catch {
+		return null;
+	}
+}
+/** A size as the prompt says it: "3 MiB", "1.5 MiB", "200 KiB", "900 bytes". */
+function sizeWords(bytes) {
+	if (bytes >= MiB) return `${Math.round(bytes / MiB * 100) / 100} MiB`;
+	if (bytes >= 1024) return `${Math.round(bytes / 1024 * 100) / 100} KiB`;
+	return `${bytes} bytes`;
+}
+//#endregion
+//#region src/skill-acceptance.ts
+/** The file at the top of a Skill's folder that names and describes it. */
+const SKILL_FILE = "SKILL.md";
+/** How big a Skill's folder may be: its files' bytes added up, and how many files it holds. */
+const SKILL_FOLDER_LIMITS = {
+	bytes: 52428800,
+	files: 5e3
+};
+/**
+* Accepts `folder` as a Skill, or says why not, in the Owner's words. A `.git` at its top (a
+* clone's history, which differs on every machine) is deleted first: it isn't the Skill's.
+*/
+async function acceptSkill(folder) {
+	await rm(join(folder, ".git"), {
+		recursive: true,
+		force: true
 	});
 	const walked = await entriesOf(folder);
 	if (typeof walked === "string") return {
@@ -4218,8 +5253,15 @@ async function digestOf(entries) {
 //#region src/routing-skills.ts
 /** Where a repository's own Skills are looked for, in this order, each Skill a folder in them. */
 const REPOSITORY_SKILL_FOLDERS = [".claude/skills", ".agents/skills"];
+/** A repository's own instructions for agents, looked for at its root only, in this order. */
+const REPOSITORY_INSTRUCTION_FILES = ["AGENTS.md", "CLAUDE.md"];
 /** Where a Session's routing Skills are written in its Workspace, a folder each, before each launch. */
 const ROUTING_SKILLS_FOLDER = join(".moonmill", "routing");
+/**
+* The routing AGENTS.md, from the Workspace's root: in the routing folder beside the routing
+* Skills, listing the repositories' own instructions, written with them before each launch.
+*/
+const ROUTING_AGENTS_FILE = join(ROUTING_SKILLS_FOLDER, "AGENTS.md");
 /** How much of a `SKILL.md` is read for its frontmatter, which comes at its top. */
 const FRONTMATTER_BYTES = 65536;
 /**
@@ -4235,8 +5277,10 @@ function routingSkillName(folder) {
 * its own, written anew into the Workspace's `ROUTING_SKILLS_FOLDER`. A routing Skill whose name
 * one of `skills` has already (as names compare, `skillNameKey`), or an earlier repository's, is
 * left out, each Skill it would have listed in `leftOut`, saying which has its name: the Agent's
-* own Skill wins it. Undefined `repositories`: nothing is looked for, and `skills` are given as
-* they are; otherwise what was laid out before is replaced, `skills` or not.
+* own Skill wins it. The routing AGENTS.md is written there too (`ROUTING_AGENTS_FILE`), when any
+* of `repositories` carries instructions of its own. Undefined `repositories`: nothing is looked
+* for, and `skills` are given as they are; otherwise what was laid out before is replaced, `skills`
+* or not.
 */
 async function withRoutingSkills(workspace, repositories, skills) {
 	if (repositories === void 0) return {
@@ -4248,6 +5292,7 @@ async function withRoutingSkills(workspace, repositories, skills) {
 		recursive: true,
 		force: true
 	});
+	await writeRoutingAgents(workspace, repositories);
 	const given = [...skills ?? []];
 	const taken = new Map(given.map(({ name }) => [skillNameKey(name), null]));
 	const leftOut = [];
@@ -4300,6 +5345,68 @@ async function withRoutingSkills(workspace, repositories, skills) {
 	};
 }
 /**
+* Writes the routing AGENTS.md into `workspace` (`ROUTING_AGENTS_FILE`), listing each of
+* `repositories` (the folders of `workspace` they were checked out into) that carries instructions
+* of its own, in that order; nothing when none does.
+*/
+async function writeRoutingAgents(workspace, repositories) {
+	const routed = [];
+	for (const folder of repositories) {
+		const files = await instructionFilesOf(join(workspace, folder));
+		if (files.length > 0) routed.push({
+			folder,
+			files
+		});
+	}
+	if (routed.length === 0) return;
+	await mkdir(join(workspace, ROUTING_SKILLS_FOLDER), {
+		recursive: true,
+		mode: 448
+	});
+	await writeFile(join(workspace, ROUTING_AGENTS_FILE), routingAgentsFile(routed), { mode: 384 });
+}
+/**
+* The instruction files at the root of the repository at `repository`, each by its path there
+* (`<repository>/AGENTS.md`): each of `REPOSITORY_INSTRUCTION_FILES` that is a file, through any
+* links, wherever they lead. One that is a link to another listed already (a `CLAUDE.md` leading
+* to the `AGENTS.md` beside it, say) is listed once. None for a folder that isn't there.
+*/
+async function instructionFilesOf(repository) {
+	if (!await isFolder(repository)) return [];
+	const files = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const name of REPOSITORY_INSTRUCTION_FILES) {
+		const file = join(repository, name);
+		if (!await isFile(file)) continue;
+		const real = await realpath(file);
+		if (seen.has(real)) continue;
+		seen.add(real);
+		files.push(file);
+	}
+	return files;
+}
+/**
+* The routing AGENTS.md listing `routed`: each repository's folder, the absolute path of each of
+* its instruction files, which the Agent reads where it is so that what it refers to is found from
+* there, and to read them before working in that folder and follow them while working there.
+*/
+function routingAgentsFile(routed) {
+	return [
+		"# The repositories' own instructions",
+		"",
+		"These repositories in your Workspace come with instructions of their own for agents working in them. Read each file where it is, at the path given: what it refers to is found from there.",
+		"",
+		...routed.flatMap(({ folder, files }) => [
+			`## \`${folder}/\``,
+			"",
+			`Before you work in \`${folder}/\`, read ${files.length === 1 ? "this file" : "these files"}, and follow ${files.length === 1 ? "it" : "them"} while you work there:`,
+			"",
+			...files.map((file) => `- ${file}`),
+			""
+		])
+	].join("\n");
+}
+/**
 * The Skills the repository at `repository` carries: each folder of its `REPOSITORY_SKILL_FOLDERS`
 * holding a `SKILL.md` (a hidden one apart), in that order, by name within each. One reached twice
 * (`.agents/skills` a link to `.claude/skills`, say) is listed once; one the Runtimes wouldn't take,
@@ -4477,6 +5584,58 @@ function recordedSkillsFile(record) {
 * when the folder holds none (the Session was never recorded here).
 */
 async function readSessionRecord(folder) {
+	const files = await segmentFiles(folder);
+	if (files === null) return null;
+	const items = [];
+	for (const [index, file] of files.entries()) {
+		const path = join(folder, file);
+		const { items: segment } = segmentOf(index + 1, file, await readFile(path, "utf8"), await skillsNotedFor(path));
+		items.push(...segment);
+	}
+	return withinLimit(items);
+}
+/**
+* One image the record of the Session filed in `folder` names (`image`): a prompt's from the
+* Session's Workspace, `gone` once the Workspace was swept, or a tool's from the record. Either
+* must be a png, jpeg, gif or webp within `IMAGE_LIMITS.bytes`.
+*/
+async function recordImageOf(folder, image) {
+	const none = {
+		kind: "missing",
+		why: "its record names no such image"
+	};
+	const file = (await segmentFiles(folder))?.[image.segment - 1];
+	if (file === void 0) return none;
+	const text = await readFile(join(folder, file), "utf8").catch((error) => {
+		if (isMissing$1(error)) return null;
+		throw error;
+	});
+	if (text === null) return none;
+	const { images, workspace } = segmentOf(image.segment, file, text, NOTHING_NOTED);
+	const source = images[image.index];
+	if (source === void 0) return none;
+	if (source.kind === "file") return workspace === null ? {
+		kind: "missing",
+		why: "its record doesn't say which Workspace the image was in"
+	} : imageInWorkspace(workspace, source.path);
+	const bytes = Buffer.from(source.data, "base64");
+	if (bytes.length > IMAGE_LIMITS.bytes) return {
+		kind: "missing",
+		why: "the image is larger than the Owner is shown"
+	};
+	const mimeType = imageTypeOf(bytes);
+	if (mimeType === null) return {
+		kind: "missing",
+		why: "the image isn't a PNG, JPEG, GIF or WebP"
+	};
+	return {
+		kind: "image",
+		mimeType,
+		bytes
+	};
+}
+/** The files of the Session's segments in `folder`, in the order they opened; null for none. */
+async function segmentFiles(folder) {
 	let files;
 	try {
 		files = (await readdir(folder, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => entry.name).toSorted(byOpening);
@@ -4484,13 +5643,7 @@ async function readSessionRecord(folder) {
 		if (error instanceof Error && "code" in error && error.code === "ENOENT") return null;
 		throw error;
 	}
-	if (files.length === 0) return null;
-	const items = [];
-	for (const [index, file] of files.entries()) {
-		const path = join(folder, file);
-		items.push(...segmentOf(index + 1, file, await readFile(path, "utf8"), await skillsNotedFor(path)));
-	}
-	return withinLimit(items);
+	return files.length === 0 ? null : files;
 }
 /** Files in the order their segments opened: by the time their name starts with, then by name. */
 function byOpening(a, b) {
@@ -4512,6 +5665,11 @@ const skillsNoted = z.union([z.object({
 	skills,
 	leftOut: []
 }))]);
+/** Nothing noted beside a segment's log. */
+const NOTHING_NOTED = {
+	skills: [],
+	leftOut: []
+};
 /** What is noted beside segment `record`'s log: nothing where nothing is, or it can't be read. */
 async function skillsNotedFor(record) {
 	const text = await readFile(recordedSkillsFile(record), "utf8").catch(() => null);
@@ -4542,6 +5700,20 @@ function segmentOf(number, file, text, noted) {
 	const sessionId = typeof header?.sessionId === "string" ? header.sessionId : file.replace(/^\d+-|\.jsonl$/g, "");
 	const startedAt = typeof header?.startedAt === "number" ? header.startedAt : openedAtOf(file);
 	const view = viewOf(records, file);
+	const endedAt = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		if (record.agentPath.length > 0) continue;
+		for (const event of eventsOf(record)) if (event.kind === "tool_call_ended") endedAt.set(event.callId, record.seq);
+	}
+	/** The items that name images, each with them and where in the log they came. */
+	const arriving = [];
+	const name = (item, sources, at) => {
+		if (sources.length > 0) arriving.push({
+			item,
+			sources,
+			at: at ?? Number.MAX_SAFE_INTEGER
+		});
+	};
 	const items = [{
 		kind: "segment",
 		number,
@@ -4552,19 +5724,55 @@ function segmentOf(number, file, text, noted) {
 		skills: noted.skills,
 		skillsLeftOut: noted.leftOut
 	}];
-	for (const message of view.messages) if (message.kind === "input") items.push({
-		kind: "prompt",
-		text: cut(message.input.input, RECORD_LIMITS.prompt)
-	});
-	else if (message.kind === "turn") {
-		for (const section of message.sections) if (section.agentPath.length === 0) items.push(...section.parts.flatMap(itemsOf));
+	const workspace = typeof header?.cwd === "string" && header.cwd !== "" ? header.cwd : null;
+	for (const message of view.messages) if (message.kind === "input") {
+		const prompt = {
+			kind: "prompt",
+			text: cut(message.input.input, RECORD_LIMITS.prompt)
+		};
+		items.push(prompt);
+		const carried = (message.input.images ?? []).map(({ path }) => path);
+		const sent = workspace === null ? [] : chatImagesOf(message.input.input, workspace);
+		name(prompt, (sent.length > 0 ? sent : carried).map((path) => ({
+			kind: "file",
+			path
+		})), message.input.attempts.at(-1)?.request.seq);
+	} else if (message.kind === "turn") {
+		for (const section of message.sections) if (section.agentPath.length === 0) for (const part of section.parts) items.push(...itemsOf(part, (item, sources) => name(item, sources, part.kind === "tool" ? endedAt.get(part.callId) : void 0)));
 		if (message.outcome) items.push({
 			kind: "turn-ended",
 			outcome: message.outcome.kind,
 			reason: message.outcome.kind === "failed" ? cut(message.outcome.reason, RECORD_LIMITS.reason).text : null
 		});
 	}
-	return items;
+	const images = [];
+	for (const { item, sources } of arriving.toSorted((a, b) => a.at - b.at)) {
+		const named = [];
+		for (const source of sources) {
+			const image = {
+				segment: number,
+				index: images.length
+			};
+			images.push(source);
+			if (named.length < RECORD_LIMITS.images && recordImage.safeParse(image).success) named.push(image);
+		}
+		if (named.length > 0) item.images = named;
+	}
+	return {
+		items,
+		images,
+		workspace
+	};
+}
+/** A link a chat turn's prompt makes to an image of its message, in the turn's folder. */
+const CHAT_IMAGE_LINK = new RegExp(String.raw`\]\((${WORKSPACE_FOLDERS.chatTurns}/\d+/[^)\s/]+)\)`, "g");
+/**
+* The files of the images a chat turn's prompt `input` says its message came with, in order, each
+* where it is in `workspace`: every one, inside the prompt or a file only. None for another prompt.
+*/
+function chatImagesOf(input, workspace) {
+	const linked = [...input.matchAll(CHAT_IMAGE_LINK)].flatMap((match) => match[1] ?? []);
+	return [...new Set(linked)].map((path) => join(workspace, path));
 }
 /** A line of a log, or null where it isn't one (the half-written last line of a daemon that died). */
 function lineOf(line) {
@@ -4576,8 +5784,11 @@ function lineOf(line) {
 		return null;
 	}
 }
-/** The record items one part of a turn stands for. */
-function itemsOf(part) {
+/**
+* The record items one part of a turn stands for, each with the images it returned handed to
+* `name`, which numbers them among its segment's.
+*/
+function itemsOf(part, name) {
 	switch (part.kind) {
 		case "text": return [{
 			kind: "text",
@@ -4589,14 +5800,19 @@ function itemsOf(part) {
 		}];
 		case "tool": {
 			const output = toolResultText(part.content) ?? part.output;
-			return [{
+			const tool = {
 				kind: "tool",
 				callId: cut(part.callId, 200).text || "call",
 				tool: cut(part.tool, RECORD_LIMITS.tool).text || "tool",
 				input: part.input === void 0 ? null : cut(part.input, RECORD_LIMITS.toolInput),
 				result: part.result,
 				output: output === void 0 ? null : cut(output, RECORD_LIMITS.toolOutput)
-			}];
+			};
+			name(tool, (part.content ?? []).flatMap((each) => each.type === "image" ? [{
+				kind: "bytes",
+				data: each.data
+			}] : []));
+			return [tool];
 		}
 	}
 	return [];
@@ -4634,14 +5850,17 @@ const TEXT_HOLD_MS = 100;
 * The Runtime driver over oar, for the real agent CLIs this machine has (ADR-0009), with the
 * Owner's own setup in this machine's folders (`thisMachine`) unless told otherwise.
 */
-function oarRuntimeDriver({ machine = thisMachine() } = {}) {
+function oarRuntimeDriver({ machine = thisMachine(), ...options } = {}) {
 	return runtimeDriver(async (runtime) => {
 		const { defaultRuntimes } = await import("@botiverse/oar");
 		return defaultRuntimes.require(OAR_RUNTIME_IDS[runtime]);
-	}, { machine });
+	}, {
+		machine,
+		...options
+	});
 }
 /** The Runtime driver over the oar Runtimes `lookup` finds, on `machine`. */
-function runtimeDriver(lookup, { machine }) {
+function runtimeDriver(lookup, { machine, promptImageLimits = {}, retriesRefusedImages = true }) {
 	return { async open({ runtime: id, cwd, instructions, mcpServers, skills: own, repositories, model, resume, recordIn, onProblem = () => {} }) {
 		const runtime = await lookup(id);
 		const installation = await runtime.installation?.();
@@ -4672,7 +5891,12 @@ function runtimeDriver(lookup, { machine }) {
 			skills: recordedSkillsOf(skills),
 			leftOut,
 			onProblem
-		}), onProblem);
+		}), onProblem, {
+			runtime: id,
+			cwd,
+			limits: promptImageLimits[id] ?? PROMPT_IMAGE_LIMITS[id],
+			retriesRefusedImages
+		});
 	} };
 }
 /**
@@ -4786,12 +6010,37 @@ async function newRecordFile(dir, sessionId) {
 		}
 	}
 }
-function driverSession(session, recording, onProblem) {
+/**
+* Whether a prompt that carried images was refused in a way they may have caused: oar refused it
+* (an image it couldn't deliver, or the Runtime's own no), or the provider failed the turn as too
+* large or an invalid request. A prompt refused for being busy, or a Session that ended, isn't.
+*/
+function refusedItsImages(run) {
+	if (run.kind === "rejected") return run.code === "unsupported" || run.code === "runtime_refused" || run.code === "error";
+	return run.kind === "ended" && run.outcome.kind === "failed" && (run.outcome.failure === "input_too_large" || run.outcome.failure === "invalid_request");
+}
+function driverSession(session, recording, onProblem, prompted) {
 	return {
 		id: session.id,
 		recording: recording?.path ?? null,
-		async run(input, signal) {
-			const run = await promptAndWait(session, input, signal ? { signal } : {});
+		async run(prompt, signal) {
+			const { retriesRefusedImages, ...how } = prompted;
+			const deliver = async (refused) => {
+				const { input, images } = await deliveredPrompt(prompt, {
+					...how,
+					takesImages: session.capabilities.images,
+					refused
+				});
+				return {
+					run: await promptAndWait(session, input, {
+						...signal ? { signal } : {},
+						...images.length > 0 ? { images } : {}
+					}),
+					carried: images.length > 0
+				};
+			};
+			const first = await deliver(false);
+			const { run } = retriesRefusedImages && first.carried && refusedItsImages(first.run) ? await deliver(true) : first;
 			if (run.kind === "rejected") return {
 				kind: "failed",
 				failure: run.code,
@@ -4845,7 +6094,7 @@ function driverSession(session, recording, onProblem) {
 //#endregion
 //#region src/official-skills.ts
 /** The Version an official Skill is recorded at: this daemon's, by its protocol. */
-const OFFICIAL_SKILLS_VERSION = `protocol 24`;
+const OFFICIAL_SKILLS_VERSION = `protocol 25`;
 /** What every official Skill's instructions end with: no credential, and how to say it failed. */
 const NEVER = `Never ask for a password or token, and never write one into a link, a command or a
 file. If the source can't be reached, the Version isn't there, or there's no \`SKILL.md\` where the
@@ -5198,7 +6447,7 @@ async function openMillwright(options) {
 		const skills = await writeOfficialSkills(folders.skills);
 		for (const binding of setup?.skills ?? []) {
 			const folder = ownCopyFolder(stateDir, binding.skillId, binding.version.digest);
-			if (nameTakenBy(binding.name, skills.map(({ name }) => name)) !== null || !await isThere$1(folder)) continue;
+			if (nameTakenBy(binding.name, skills.map(({ name }) => name)) !== null || !await isThere$2(folder)) continue;
 			const { version, digest } = binding.version;
 			skills.push({
 				name: binding.name,
@@ -5468,12 +6717,12 @@ async function openMillwright(options) {
 		for (const copy of filed) if (now.skills.some((each) => copy === ownCopyFolder(stateDir, each.skillId, each.version.digest))) filed.delete(copy);
 		for (const binding of now.skills) {
 			const folder = ownCopyFolder(stateDir, binding.skillId, binding.version.digest);
-			if (owning.has(folder) || await isThere$1(folder)) continue;
+			if (owning.has(folder) || await isThere$2(folder)) continue;
 			if (binding.fromCheck !== null && await adopt(binding, binding.fromCheck, folder)) continue;
 			owning.add(folder);
 			enqueue("own", async () => {
 				try {
-					if (stopping || killed || !stillNamed(binding) || await isThere$1(folder)) return;
+					if (stopping || killed || !stillNamed(binding) || await isThere$2(folder)) return;
 					const { version, digest } = binding.version;
 					const installed = await installInto({
 						label: binding.skillId,
@@ -5913,9 +7162,9 @@ function createSkillCopies(options) {
 	* the Millwright installs. Why it couldn't, in the Owner's words, or null once it is there.
 	*/
 	const makeCopy = async (agentId, binding, folder, signal) => {
-		if (await isThere$1(folder)) return null;
+		if (await isThere$2(folder)) return null;
 		if (binding.fromCheck !== null && await adopt(agentId, binding.skillId, binding.fromCheck, folder)) return null;
-		if (await isThere$1(folder)) return null;
+		if (await isThere$2(folder)) return null;
 		const { version, digest } = binding.version;
 		const installed = await millwright.install({
 			label: binding.skillId,
@@ -6129,7 +7378,7 @@ function createSkillCopies(options) {
 			for (const { agentId, skills } of agents) for (const binding of skills) {
 				if (binding.fromCheck === null) continue;
 				const folder = agentCopyFolder(stateDir, agentId, binding.skillId, binding.version.digest);
-				if (taking.has(folder) || installing.has(folder) || await isThere$1(folder)) continue;
+				if (taking.has(folder) || installing.has(folder) || await isThere$2(folder)) continue;
 				hold(folder);
 				try {
 					await adopt(agentId, binding.skillId, binding.fromCheck, folder);
@@ -6300,7 +7549,7 @@ const HAND_OFF_GUIDANCE = [
 	`When the work is done, call the \`${HAND_OFF_TOOL}\` tool of the \`${FACTORY_MCP_NAME}\` MCP server exactly once, as your last action, then stop. Its arguments:`,
 	"",
 	"- `markdown`: your Hand-off, a document in Markdown: what you did, what you found, and what whoever reads it next needs to know.",
-	`- \`images\` (optional): up to ${HAND_OFF_LIMITS.images} image files in this Workspace (${HAND_OFF_IMAGE_TYPES.map((type) => type.replace("image/", "").toUpperCase()).join(", ")}; at most ${HAND_OFF_LIMITS.imageBytes / 1024} KiB each), as \`{ "path": "…", "alt": "…" }\`.`,
+	`- \`images\` (optional): up to ${IMAGE_LIMITS.images} image files in this Workspace (${IMAGE_TYPES.map((type) => type.replace("image/", "").toUpperCase()).join(", ")}; at most ${IMAGE_LIMITS.bytes / 1024 / 1024} MiB each), as \`{ "path": "…", "alt": "…" }\`.`,
 	`- \`references\` (optional): up to ${HAND_OFF_LIMITS.references} materials you produced, each \`{ "label": "…", "target": "…" }\` with a URL or a pinned identifier as the target, such as a pushed commit.`,
 	"",
 	"A Hand-off is a document, not a delivery of files: put materials (code, data, archives) where they belong, such as a pushed branch, and reference them. Nothing in this Workspace is kept for whoever comes next."
@@ -6310,7 +7559,7 @@ const HAND_OFF_GUIDANCE = [
 * the tool returns at once, and the reply continues the Session (ADR-0009).
 */
 const HELP_GUIDANCE = [
-	`If you can't go on without the Owner (something only they know or can decide), call the \`${HELP_TOOL}\` tool of the \`${FACTORY_MCP_NAME}\` MCP server with your \`question\`, in Markdown: what you need to know, and what you found that makes you ask.`,
+	`If you can't go on without the Owner (something only they know or can decide), call the \`${HELP_TOOL}\` tool of the \`${FACTORY_MCP_NAME}\` MCP server with your \`question\`, in Markdown: what you need to know, and what you found that makes you ask. To show the Owner what you see, add \`images\`: up to ${IMAGE_LIMITS.images} image files in this Workspace, as \`{ "path": "…", "alt": "…" }\`; the Owner sees them as they are when you ask.`,
 	"",
 	"It returns at once. Then end your turn without handing off: the Owner's reply continues this Session where you left off, as your next prompt. Ask one question at a time, and only when you're stuck."
 ].join("\n");
@@ -6322,6 +7571,7 @@ const JUDGE_GUIDANCE = [
 	"",
 	"- `outcome`: `\"passed\"` when the Hand-off meets every criterion, `\"failed\"` when it misses any.",
 	`- \`annotations\` (when it failed): Markdown saying which criteria the Hand-off doesn't meet and why, for whoever works on it next and for the Owner; at most ${HAND_OFF_LIMITS.markdown.toLocaleString("en")} characters.`,
+	`- \`images\` (optional, when it failed): up to ${IMAGE_LIMITS.images} image files in this Workspace that show what is wrong, such as a screenshot (${IMAGE_TYPES.map((type) => type.replace("image/", "").toUpperCase()).join(", ")}; at most ${IMAGE_LIMITS.bytes / 1024 / 1024} MiB each), as \`{ "path": "…", "alt": "…" }\`; they go beside the annotations.`,
 	"",
 	"Judge the Hand-off as it is: don't redo the work or fix it, and change nothing it references. Reach the materials it references the way this machine can."
 ].join("\n");
@@ -6342,40 +7592,76 @@ const WORKPIECE_DIR = WORKSPACE_FOLDERS.workpiece;
 const UNDER_CHECK_DIR = WORKSPACE_FOLDERS.underCheck;
 /** The folder of a Rework's Workspace holding the Hand-off of the attempt it follows. */
 const PREVIOUS_ATTEMPT_DIR = WORKSPACE_FOLDERS.previousAttempt;
-/** The file extension of each image type a Hand-off may carry. */
-const IMAGE_EXTENSIONS = {
-	"image/png": "png",
-	"image/jpeg": "jpg",
-	"image/gif": "gif",
-	"image/webp": "webp"
+/** A Workpiece written as its brief alone, with no images: nothing in the Workspace. */
+const NOTHING_WRITTEN = {
+	brief: null,
+	handOffs: []
 };
 /**
-* Writes the Workpiece as it stands into a Session's Workspace (spec stories 24 and 35): when
-* earlier stations' Hand-offs were accepted, `workpiece/` holds its brief and each of those
-* Hand-offs as a Markdown file, with the Hand-off's images beside it, all fetched from the Platform.
-* Returns the files in Pipeline order, for the instructions to point at: none at the first station,
-* whose Workpiece is its brief alone.
+* Writes the Workpiece as it stands into a Session's Workspace (spec stories 24 and 35, and #172's
+* 28-30): when its brief carries images or earlier stations' Hand-offs were accepted, `workpiece/`
+* holds its brief as a Markdown file with the brief's images beside it (`brief-1.png`…), read from
+* the image store, and each of those Hand-offs as a Markdown file, with the Hand-off's images beside
+* it, all fetched from the Platform. Nothing at the first station for a brief without images: its
+* Workpiece is its brief alone, in the instructions.
 */
 async function writeWorkpiece(workspace, task, documents) {
-	const { handOffs } = task.workpiece;
-	if (handOffs.length === 0) return [];
+	const { handOffs, images } = task.workpiece;
+	if (handOffs.length === 0 && images.length === 0) return NOTHING_WRITTEN;
 	const dir = join(workspace, WORKPIECE_DIR);
 	await mkdir(dir, { mode: 448 });
-	await writeFile(join(dir, "brief.md"), `${task.workpiece.brief}\n`, { mode: 384 });
-	const files = [{
+	const briefImages = await writeBriefImages(workspace, task, documents);
+	const text = [task.workpiece.brief, ...briefImages.length > 0 ? ["## Images", imageLinks(briefImages, WORKPIECE_DIR)] : []].join("\n\n");
+	await writeFile(join(dir, "brief.md"), `${text}\n`, { mode: 384 });
+	const brief = {
 		path: `${WORKPIECE_DIR}/brief.md`,
-		description: "the brief"
-	}];
+		description: `the brief${besideIt(briefImages.length)}`,
+		images: briefImages
+	};
+	const files = [];
 	for (const [index, made] of handOffs.entries()) {
 		const document = await documents.handOff(task.task.id, made.id);
-		const stem = `${index + 1}-${slugOf(made.workstation.name)}`;
-		const images = await writeHandOff(dir, stem, document, (number) => documents.image(task.task.id, made.id, number));
+		const beside = {
+			folder: WORKPIECE_DIR,
+			stem: `${index + 1}-${slugOf(made.workstation.name)}`
+		};
+		const written = await writeHandOff(workspace, beside, document, documents);
 		files.push({
-			path: `${WORKPIECE_DIR}/${stem}.md`,
-			description: `the Hand-off of ${made.agent.name} at the Workstation "${made.workstation.name}"${beside(images)}`
+			path: `${WORKPIECE_DIR}/${beside.stem}.md`,
+			description: `the Hand-off of ${made.agent.name} at the Workstation "${made.workstation.name}"${besideIt(written)}`
 		});
 	}
-	return files;
+	return {
+		brief,
+		handOffs: files
+	};
+}
+/**
+* Writes the images of the brief into `workpiece/` beside `brief.md`, as the message starting the
+* Session names them, each read from the image store at an address fetched for the Task.
+*/
+async function writeBriefImages(workspace, task, documents) {
+	const { images } = task.workpiece;
+	if (images.length === 0) return [];
+	const fetched = await documents.brief(task.task.id);
+	return writeImages(workspace, {
+		folder: WORKPIECE_DIR,
+		stem: "brief"
+	}, images, fromStore(documents, images, fetched.images, "the brief's image"));
+}
+/**
+* How `writeImages` reads `named`'s bytes from the image store: each at the address `addressed`
+* gives the same key (a document fetched for its addresses), or each at its own (`addressed`
+* omitted: `named` carries them). Rejects naming `what` ("the brief's image") for one it has no
+* address for.
+*/
+function fromStore(documents, named, addressed, what) {
+	return (index) => {
+		const image = named[index];
+		const address = addressed === void 0 ? image?.address : addressed.find(({ key }) => key === image?.key)?.address;
+		if (!address) return Promise.reject(/* @__PURE__ */ new Error(`${what} ${index + 1} isn't on the Platform`));
+		return documents.image(address);
+	};
 }
 /**
 * Writes the Hand-off under check into an Inspector's Workspace (spec story 24): `hand-off/` holds
@@ -6384,71 +7670,109 @@ async function writeWorkpiece(workspace, task, documents) {
 */
 async function writeHandOffUnderCheck(workspace, task, documents) {
 	const { handOff } = task.check;
-	const dir = join(workspace, UNDER_CHECK_DIR);
-	await mkdir(dir, { mode: 448 });
-	const images = await writeHandOff(dir, "hand-off", await documents.handOff(task.task.id, handOff.id), (number) => documents.image(task.task.id, handOff.id, number));
+	await mkdir(join(workspace, UNDER_CHECK_DIR), { mode: 448 });
+	const document = await documents.handOff(task.task.id, handOff.id);
+	const images = await writeHandOff(workspace, {
+		folder: UNDER_CHECK_DIR,
+		stem: "hand-off"
+	}, document, documents);
 	return {
 		path: `${UNDER_CHECK_DIR}/hand-off.md`,
-		description: `the Hand-off of ${handOff.agent.name} at the Workstation "${task.workstation.name}"${beside(images)}`
+		description: `the Hand-off of ${handOff.agent.name} at the Workstation "${task.workstation.name}"${besideIt(images)}`
 	};
 }
 /**
 * Writes the Hand-off of the attempt a Rework follows into its Workspace (spec story 33), if that
 * attempt handed off: `previous-attempt/` holds it as a Markdown file, its references listed at its
-* end, with its images beside it, all fetched from the Platform. Returns the file, for the
-* instructions to point at (its description says only what lies beside it), or null.
+* end, with its images beside it, and the images beside the annotations of the check it failed
+* (`annotations-1.png`…, #184), all fetched from the Platform. Returns them, for the instructions
+* to point at, or null.
 */
 async function writePreviousAttempt(workspace, task, documents) {
 	const made = task.previous?.handOff;
 	if (!made) return null;
-	const dir = join(workspace, PREVIOUS_ATTEMPT_DIR);
-	await mkdir(dir, { mode: 448 });
-	const images = await writeHandOff(dir, "hand-off", await documents.handOff(task.task.id, made.id), (number) => documents.image(task.task.id, made.id, number));
+	await mkdir(join(workspace, PREVIOUS_ATTEMPT_DIR), { mode: 448 });
+	const document = await documents.handOff(task.task.id, made.id);
+	const images = await writeHandOff(workspace, {
+		folder: PREVIOUS_ATTEMPT_DIR,
+		stem: "hand-off"
+	}, document, documents);
+	const failed = task.previous?.check?.id;
 	return {
 		path: `${PREVIOUS_ATTEMPT_DIR}/hand-off.md`,
-		description: beside(images)
+		description: besideIt(images),
+		annotationImages: failed ? await writeAnnotationImages(workspace, task, failed, documents) : []
 	};
 }
 /**
-* Writes `document` as `<stem>.md` in `dir`, its images beside it as `<stem>-1.png`… (fetched with
-* `image`) and its references listed at its end. Returns how many images it has.
+* Writes the images beside the annotations of check `checkId`, which failed the attempt a Rework
+* follows, into `previous-attempt/` beside its Hand-off, as `annotations-1.png`…, fetched from the
+* Platform and read from the image store. Returns them as written.
 */
-async function writeHandOff(dir, stem, document, image) {
-	const images = [];
-	for (const [number, each] of document.images.entries()) {
-		const file = `${stem}-${number + 1}.${IMAGE_EXTENSIONS[each.mimeType]}`;
-		await writeFile(join(dir, file), await image(number), { mode: 384 });
-		images.push(`![${each.alt ?? `Image ${number + 1}`}](${file})`);
+async function writeAnnotationImages(workspace, task, checkId, documents) {
+	const { images } = await documents.annotations(task.task.id, checkId);
+	return writeImages(workspace, {
+		folder: PREVIOUS_ATTEMPT_DIR,
+		stem: "annotations"
+	}, images, fromStore(documents, images, void 0, "the annotations' image"));
+}
+/**
+* Writes the images of the Owner's Verdicts on the Workpiece (#183: a Send back's or a Rework's
+* guidance's, an Approve's note's) into `workpiece/`, each Verdict's named after its Ticket
+* (`T-3-verdict-1.png`…), read from the image store at addresses fetched for the Task. Returns them
+* as written, for the instructions to name under what the Owner decided and the first prompt to
+* carry those of the Verdict that routed the Workpiece to the Task.
+*/
+async function writeVerdictImages(workspace, task, documents) {
+	const named = task.verdicts.map(({ verdict }) => imagesOf(verdict));
+	if (named.every((images) => images.length === 0)) return [];
+	const fetched = await documents.verdicts(task.task.id);
+	const written = [];
+	for (const [index, { ticket }] of task.verdicts.entries()) {
+		const images = named[index] ?? [];
+		const label = ticketLabel(ticket);
+		const beside = {
+			folder: WORKPIECE_DIR,
+			stem: `${label}-verdict`
+		};
+		written.push(await writeImages(workspace, beside, images, fromStore(documents, images, fetched.images, `the Verdict on ${label}'s image`)));
 	}
+	return written;
+}
+/**
+* Writes a Hand-off into `workspace` as the document `beside` names, `<stem>.md` in its folder, its
+* images beside it (`writeImages`, their bytes read from the image store at the addresses the
+* document names) and linked under its text, and its references listed at its end. Returns how
+* many images it has.
+*/
+async function writeHandOff(workspace, beside, document, documents) {
+	const images = await writeImages(workspace, beside, document.images, fromStore(documents, document.images, void 0, "the Hand-off's image"));
 	const references = document.references.map(({ label, target }) => `- ${label}: ${target}`);
 	const text = [
 		document.markdown,
-		...images.length > 0 ? ["## Images", images.join("\n")] : [],
+		...images.length > 0 ? ["## Images", imageLinks(images, beside.folder)] : [],
 		...references.length > 0 ? ["## References", references.join("\n")] : []
 	].join("\n\n");
-	await writeFile(join(dir, `${stem}.md`), `${text}\n`, { mode: 384 });
+	await writeFile(join(workspace, beside.folder, `${beside.stem}.md`), `${text}\n`, { mode: 384 });
 	return images.length;
 }
-/** ", with its image beside it", for a Hand-off file with `images` images. */
-function beside(images) {
-	if (images === 0) return "";
-	return `, with its ${images === 1 ? "image" : `${images} images`} beside it`;
-}
 /** A Workstation's name as part of a file name: "Draft PR" → "draft-pr". */
 function slugOf(name) {
 	return name.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40).replace(/-+$/, "") || "hand-off";
 }
 /**
-* The Agent's instructions for a Session, which its Runtime gets as the Runtime driver launches it
-* (`launch.ts`), the same on each launch of the Session. For a Workstation Task's work: the Agent's
-* own instructions, the brief, the `workpiece` files so far, if any, what went wrong with the
-* attempt before it if it is a Rework or a round a Verdict started (pointing at its Hand-off,
-* `previous`), what the Owner decided about the Workpiece so far, how its Hand-off is checked on
-* the Belt out of its Workstation if it is, and how to hand off. For a check: the Inspector's
-* instructions, the Belt's criteria, the Hand-off under check (`underCheck`), the brief and the
-* Workpiece so far, and how to judge.
+* The Agent's instructions for a Session in `workspace`, which its Runtime gets as the Runtime
+* driver launches it (`launch.ts`), the same on each launch of the Session. For a Workstation
+* Task's work: the Agent's own instructions, the brief (naming each of its images where it lies in
+* the Workspace), the repositories checked out, if any, the `workpiece` files so far, if any, what
+* went wrong with the attempt before it if it is a Rework or a round a Verdict started (pointing at
+* its Hand-off, `previous`), what the Owner decided about the Workpiece so far, how its Hand-off is
+* checked on the Belt out of its Workstation if it is, and how to hand off. For a check: the
+* Inspector's instructions, the Belt's criteria, the Hand-off under check (`underCheck`), the brief
+* with its images, the repositories checked out, if any, and the Workpiece so far, and how to
+* judge.
 */
-function instructionsFor(task, { workpiece = [], underCheck = null, previous = null } = {}) {
+function instructionsFor(task, workspace, { workpiece = NOTHING_WRITTEN, underCheck = null, previous = null, verdicts = [] } = {}) {
 	const { agent, pipeline, workstation } = task;
 	const instructions = agent.instructions.trim() || "You have none beyond the brief: work from the brief alone.";
 	if (task.role === "check") {
@@ -6470,11 +7794,8 @@ function instructionsFor(task, { workpiece = [], underCheck = null, previous = n
 			"",
 			underCheck ? `It is \`${underCheck.path}\`: ${underCheck.description}. Its references, if any, are listed at its end.` : `It is ${check.handOff.agent.name}'s Hand-off.`,
 			"",
-			"## The brief",
-			"",
-			task.workpiece.brief,
-			"",
-			...checkedOut(task),
+			...theBrief(task, workpiece),
+			...checkedOut(task, workspace),
 			...soFar(workpiece, "the Hand-off under check builds on theirs"),
 			"## How to judge",
 			"",
@@ -6482,7 +7803,7 @@ function instructionsFor(task, { workpiece = [], underCheck = null, previous = n
 			""
 		].join("\n");
 	}
-	const empty = workpiece.length === 0 && !previous && task.repositories.length === 0;
+	const empty = workpiece.brief === null && !previous && task.repositories.length === 0 && verdicts.every((images) => images.length === 0);
 	return [
 		`# ${agent.name}: Workstation Task`,
 		"",
@@ -6492,14 +7813,11 @@ function instructionsFor(task, { workpiece = [], underCheck = null, previous = n
 		"",
 		instructions,
 		"",
-		"## The brief",
-		"",
-		task.workpiece.brief,
-		"",
-		...checkedOut(task),
+		...theBrief(task, workpiece),
+		...checkedOut(task, workspace),
 		...soFar(workpiece, "your work carries theirs on"),
 		...lastTime(task, previous),
-		...ownersVerdicts(task),
+		...ownersVerdicts(task, verdicts),
 		...checkedOnward(task),
 		"## How to hand off",
 		"",
@@ -6513,11 +7831,11 @@ function instructionsFor(task, { workpiece = [], underCheck = null, previous = n
 }
 /**
 * The instructions' section on what went wrong with the attempt this one follows (spec story 33):
-* which attempt this is, why the last one didn't get through (the check's annotations, or why it
-* failed), and where its Hand-off is, if it made one. A round a Verdict started follows the
-* Workpiece's latest attempt at the Workstation, and says so; when the Owner sent the Workpiece
-* back after that attempt got through (`accepted`), it says that instead. None for a round its
-* arrival started.
+* which attempt this is, why the last one didn't get through (the check's annotations, with where
+* the images beside them are, or why it failed), and where its Hand-off is, if it made one. A round
+* a Verdict started follows the Workpiece's latest attempt at the Workstation, and says so; when the
+* Owner sent the Workpiece back after that attempt got through (`accepted`), it says that instead.
+* None for a round its arrival started.
 */
 function lastTime(task, handOff) {
 	const { attempt, previous } = task;
@@ -6542,7 +7860,8 @@ function lastTime(task, handOff) {
 			`${previous.check.inspector.name}'s annotations:`,
 			"",
 			previous.check.annotations,
-			""
+			"",
+			...annotatedWith(previous.check.inspector.name, handOff?.annotationImages ?? [])
 		] : [
 			`Why ${what}:`,
 			"",
@@ -6552,9 +7871,25 @@ function lastTime(task, handOff) {
 		...askedTheOwner(previous)
 	];
 }
-/** The questions the previous attempt asked the Owner, with their replies (spec story 61). */
+/**
+* Where the images an Inspector put beside its annotations are (#184), named from the Workspace's
+* root under the annotations; nothing when there are none.
+*/
+function annotatedWith(inspector, images) {
+	if (images.length === 0) return [];
+	return [
+		`${inspector}'s ${images.length === 1 ? "image" : `${images.length} images`} with the annotations, beside that Hand-off:`,
+		"",
+		imageLinks(images, ""),
+		""
+	];
+}
+/**
+* The questions the previous attempt asked the Owner, with their replies (spec story 61), and how
+* many images each reply came with (#186).
+*/
 function askedTheOwner(previous) {
-	return previous.help.flatMap(({ question, reply }, index) => [
+	return previous.help.flatMap(({ question, reply, replyImages }, index) => [
 		`### Attempt ${previous.attempt} asked the Owner${previous.help.length > 1 ? ` (question ${index + 1})` : ""}`,
 		"",
 		question,
@@ -6563,30 +7898,57 @@ function askedTheOwner(previous) {
 			"The Owner replied:",
 			"",
 			reply,
-			""
+			"",
+			...replyImagesWent(replyImages)
 		]
 	]);
 }
 /**
+* What an Agent after a reply is told of the images it came with (#186, ADR-0025): how many, and
+* that they went only to the Session it resumed, never down the line. Nothing for a reply in words
+* alone.
+*/
+function replyImagesWent(count) {
+	if (count === 0) return [];
+	return [`The reply came with ${count === 1 ? "an image" : `${count} images`}, which went only to the Session it resumed.`, ""];
+}
+/**
 * The instructions' section on what the Owner decided about the Workpiece so far (spec story 37):
 * each of their Verdicts on its Tickets, in the order given, with the guidance, note or reply it
-* carries. None before the Owner gave one.
+* carries, and the images beside those words, each named where it is in the Workspace (`written`,
+* #183), or, for a reply, how many it came with, which went to the Session it resumed alone (#186).
+* None before the Owner gave one.
 */
-function ownersVerdicts(task) {
+function ownersVerdicts(task, written) {
 	if (task.verdicts.length === 0) return [];
 	return [
 		"## What the Owner decided",
 		"",
 		"The Owner ruled on this Workpiece's Tickets as it came down the line. Follow what they decided, in the order they decided it:",
 		"",
-		...task.verdicts.flatMap(({ ticket, verdict }) => [
+		...task.verdicts.flatMap(({ ticket, verdict }, index) => [
 			`### ${ticketLabel(ticket)} at "${ticket.workstation.name}": ${VERDICT_NAMES[verdict.kind]}`,
 			"",
 			wordsOf(verdict) ?? withoutWords(verdict, ticket.workstation.name),
-			""
+			"",
+			...shownWith(written[index] ?? []),
+			...verdict.kind === "reply" ? replyImagesWent(verdict.images?.length ?? 0) : []
 		])
 	];
 }
+/**
+* Where the images beside a Verdict's words are in the Workspace, named from its root under the
+* words; nothing when there are none.
+*/
+function shownWith(images) {
+	if (images.length === 0) return [];
+	return [
+		images.length === 1 ? "Its image is a file in this Workspace:" : `Its ${images.length} images are files in this Workspace:`,
+		"",
+		imageLinks(images, ""),
+		""
+	];
+}
 /** What a Verdict that carries no words of the Owner's decided, said for the Agent. */
 function withoutWords(verdict, workstation) {
 	let said = "";
@@ -6619,10 +7981,13 @@ function checkedOnward(task) {
 	];
 }
 /**
-* The instructions' section on the repositories checked out into the Workspace (#90), each in its
-* folder, in the order its policy names them; none when it names none.
+* The instructions' section on the repositories checked out into `workspace` (#90), each in its
+* folder, in the order its policy names them, and where the routing AGENTS.md lists their own
+* instructions if any of them carries some (#173, `routing-skills.ts`): it is written anew on each
+* launch, and the instructions are fixed when the Session starts, so they name it whenever there
+* are repositories, "if it is there". None when its policy names none.
 */
-function checkedOut({ repositories }) {
+function checkedOut({ repositories }, workspace) {
 	if (repositories.length === 0) return [];
 	return [
 		"## The repositories in your Workspace",
@@ -6630,15 +7995,17 @@ function checkedOut({ repositories }) {
 		...repositories.map(({ url, ref, folder }) => `- \`${folder}/\`: ${url} at ${refWords(ref)}`),
 		"",
 		"Each is a fresh checkout in a folder of its own, made with this machine's own git access, which you fetch and push with too. This folder itself is no repository.",
+		"",
+		`If \`${join(workspace, ROUTING_AGENTS_FILE)}\` is there, it lists these repositories' own instructions for agents: read it before you work in one of them.`,
 		""
 	];
 }
 /**
-* A chat's instructions: who the Agent is and where it has its place, its instructions, the
-* repositories checked out into the Workspace, and that the Owner is talking with it directly.
-* Nothing of any Workpiece.
+* A chat's instructions, in its Workspace `workspace`: who the Agent is and where it has its place,
+* its instructions, the repositories checked out into the Workspace, and that the Owner is talking
+* with it directly. Nothing of any Workpiece.
 */
-function chatInstructionsFor(say) {
+function chatInstructionsFor(say, workspace) {
 	const { agent, place } = say;
 	const where = place === null ? "You have no place on a line yet." : place.kind === "workstation" ? `You staff the Workstation "${place.workstation.name}" of the Pipeline "${place.pipeline.name}".` : `You inspect the Hand-offs on the Belt from the Workstation "${place.from.name}" to "${place.to.name}" of the Pipeline "${place.pipeline.name}".`;
 	const empty = say.repositories.length === 0;
@@ -6651,42 +8018,126 @@ function chatInstructionsFor(say) {
 		"",
 		agent.instructions.trim() || "You have none: answer as yourself.",
 		"",
-		...checkedOut(say),
+		...checkedOut(say, workspace),
 		"## This chat",
 		"",
 		"No Workpiece comes with it, and nothing you do here moves on along a line. Answer the Owner, look at what they ask about with this machine's own access, and say what you find.",
 		""
 	].join("\n");
 }
-/** The instructions' section on the Workpiece so far, pointing at its files, if any. */
-function soFar(workpiece, because) {
-	return workpiece.length === 0 ? [] : [
-		"## The Workpiece so far",
-		"",
-		`Earlier Workstations of this Pipeline worked on this Workpiece before you. Its brief and every Hand-off accepted so far are files in \`${WORKPIECE_DIR}/\`, in Pipeline order:`,
-		"",
-		...workpiece.map((file, index) => `${index + 1}. \`${file.path}\`: ${file.description}.`),
-		"",
-		`Read them before you start: ${because}.`,
-		""
-	];
+/**
+* What the Agent is told in a turn of a chat: the Owner's message, as they wrote it; and the images
+* it came with (#187), inside this prompt where its Runtime takes them (`prompt-images.ts`), each a
+* file in the chat's Workspace beside the turn (`chat-turns/<turn>/message-1.png`…), or, when they
+* couldn't be kept, how many there were. What follows the Owner's words, the protocol's `chatSaid`
+* leaves out again, for the Owner reading the chat back.
+*/
+function chatPromptFor(message, { written, lost } = {
+	written: [],
+	lost: 0
+}) {
+	const which = lost === 1 ? "an image" : `${lost} images`;
+	return {
+		text: lost > 0 ? `${message}\n\nThis message came with ${which}, which couldn't be kept on this machine for you.` : message,
+		images: [{
+			of: CHAT_MESSAGE_IMAGES,
+			images: written
+		}]
+	};
 }
 /**
-* What the Agent is told when its Session resumes with the Owner's reply to its question: the reply,
-* and to carry on.
+* The instructions' section on the brief: its words, and its images, each named where it is in the
+* Workspace, beside a copy of the brief.
 */
-function replyPromptFor(task, reply) {
-	const { name: file } = INSTRUCTIONS_ARE[task.agent.runtime];
+function theBrief(task, { brief }) {
+	const images = brief?.images ?? [];
 	return [
+		"## The brief",
+		"",
+		task.workpiece.brief,
+		"",
+		...brief && images.length > 0 ? [
+			`${images.length === 1 ? "Its image is a file" : `Its ${images.length} images are files`} in this Workspace, beside a copy of the brief, \`${brief.path}\`:`,
+			"",
+			imageLinks(images, ""),
+			""
+		] : []
+	];
+}
+/**
+* The instructions' section on the Workpiece so far, pointing at its files: once earlier stations'
+* Hand-offs were accepted.
+*/
+function soFar({ brief, handOffs }, because) {
+	const files = brief ? [brief, ...handOffs] : handOffs;
+	return handOffs.length === 0 ? [] : [
+		"## The Workpiece so far",
+		"",
+		`Earlier Workstations of this Pipeline worked on this Workpiece before you. Its brief and every Hand-off accepted so far are files in \`${WORKPIECE_DIR}/\`, in Pipeline order:`,
+		"",
+		...files.map((file, index) => `${index + 1}. \`${file.path}\`: ${file.description}.`),
+		"",
+		`Read them before you start: ${because}.`,
+		""
+	];
+}
+/**
+* What the Agent is told when its Session resumes with the Owner's reply to its question: the
+* reply, and to carry on; and the images the reply came with (#186), inside this prompt where its
+* Runtime takes them (`prompt-images.ts`), each a file beside the question in its Workspace.
+*/
+function replyPromptFor(task, reply, { written, lost } = {
+	written: [],
+	lost: 0
+}) {
+	const { name: file } = INSTRUCTIONS_ARE[task.agent.runtime];
+	const lines = [
 		"The Owner replied to your question:",
 		"",
 		reply,
 		"",
 		`Carry on with the work where you left off, then hand off with the ${HAND_OFF_TOOL} tool of the ${FACTORY_MCP_NAME} MCP server, as ${file} explains.`
-	].join("\n");
+	];
+	if (lost > 0) {
+		const which = lost === 1 ? "an image" : `${lost} images`;
+		lines.push("", `The reply came with ${which}, which couldn't be kept on this machine for you.`);
+	}
+	return {
+		text: lines.join("\n"),
+		images: [{
+			of: "the reply",
+			images: written
+		}]
+	};
+}
+/**
+* What the Agent is told when its Session starts, a Task's or a Check's (the rest is in its
+* instructions), and the images that come with it (spec #172, stories 29 and 32), as `files` wrote
+* them into its Workspace, inside this first prompt where its Runtime takes them
+* (`prompt-images.ts`), and in no later one: for the Task a Verdict routed the Workpiece to
+* (`routedHere`), that Verdict's guidance's or note's (#183), then the brief's, so that a brief
+* with as many images as a prompt takes can't push the Verdict's out of it. An Agent after it has
+* that Verdict's images as files only.
+*/
+function promptFor(task, { workpiece = NOTHING_WRITTEN, verdicts = [] } = {}) {
+	const images = [];
+	if (task.role === "work") {
+		for (const [index, { verdict, routedHere }] of task.verdicts.entries()) if (routedHere) images.push({
+			of: verdict.kind === "approve" ? "the Owner's note" : "the Owner's guidance",
+			images: verdicts[index] ?? []
+		});
+	}
+	images.push({
+		of: "the brief",
+		images: workpiece.brief?.images ?? []
+	});
+	return {
+		text: firstWords(task),
+		images
+	};
 }
-/** What the Agent is told when its Session starts; the rest is in its instructions. */
-function promptFor(task) {
+/** The words of a Session's first prompt. */
+function firstWords(task) {
 	const { where, name: file } = INSTRUCTIONS_ARE[task.agent.runtime];
 	if (task.role === "check") return `Your instructions, the Belt's criteria and the Hand-off to check are ${where}. Judge the Hand-off against the criteria, then record your judgement with the ${JUDGE_TOOL} tool of the ${FACTORY_MCP_NAME} MCP server, as ${file} explains.`;
 	return `Your instructions and this Workpiece's brief are ${where}${task.workpiece.handOffs.length === 0 ? "" : `, and it points you to what the Workstations before yours handed off`}.${!task.previous ? "" : task.previous.status === "accepted" ? ` This is attempt ${task.attempt.number} of ${task.attempt.of} of a fresh round: the Owner sent the Workpiece back here, as ${file} says.` : ` This is attempt ${task.attempt.number} of ${task.attempt.of}${task.cause === "verdict" ? " of a fresh round the Owner started" : ""}: ${file} says what went wrong with the last one.`}${task.verdicts.length === 0 ? "" : ` Follow what the Owner decided about it, as ${file} says.`} Do the work the brief asks for, then hand off with the ${HAND_OFF_TOOL} tool of the ${FACTORY_MCP_NAME} MCP server, as ${file} explains.`;
@@ -6773,6 +8224,14 @@ async function isThere(workspace) {
 		return false;
 	}
 }
+/** What the images `say`'s message came with were handed for: its turn. */
+function handedFor(say) {
+	return {
+		of: "chat",
+		chatId: say.chatId,
+		turn: say.turn
+	};
+}
 /** What a turn whose Session never opened used. */
 const NONE = {
 	input: 0,
@@ -6853,7 +8312,7 @@ function createChatRunner(options) {
 		if (stop.aborted) return { failed: { kind: "aborted" } };
 		const { workspace } = chat;
 		const resume = chat.sessionId ?? void 0;
-		const instructions = (resume === void 0 ? null : chat.instructions) ?? chatInstructionsFor(say);
+		const instructions = (resume === void 0 ? null : chat.instructions) ?? chatInstructionsFor(say, workspace);
 		try {
 			return {
 				session: await options.driver.open({
@@ -6987,6 +8446,7 @@ function createChatRunner(options) {
 					instructions
 				});
 			}
+			const images = await imagesOf(say, workspace);
 			await reportStarted(say, fresh);
 			onEvent({
 				type: "chat-turn-started",
@@ -6998,7 +8458,7 @@ function createChatRunner(options) {
 				recording: opening.recording
 			});
 			return {
-				outcome: await opening.run(say.message, stop),
+				outcome: await opening.run(chatPromptFor(say.message, images), stop),
 				usage: opening.usage()
 			};
 		} finally {
@@ -7007,6 +8467,46 @@ function createChatRunner(options) {
 			await opening.close();
 		}
 	};
+	/**
+	* The images `say`'s message came with (#187), written into the turn's Workspace beside the turn
+	* (`chat-turns/<turn>/message-1.png`…), from where the Platform handed them; or how many of them
+	* there were, when they couldn't be.
+	*/
+	const imagesOf = async (say, workspace) => {
+		if (say.handed === void 0) return {
+			written: [],
+			lost: 0
+		};
+		try {
+			return {
+				written: await options.handed.claim(handedFor(say), say.handed, workspace, {
+					folder: posix.join(WORKSPACE_FOLDERS.chatTurns, String(say.turn)),
+					stem: "message"
+				}),
+				lost: 0
+			};
+		} catch (error) {
+			onEvent({
+				type: "problem",
+				message: `Couldn't write the images of turn ${say.turn} of chat ${say.chatId} into its Workspace: ${messageOf(error)}`
+			});
+			return {
+				written: [],
+				lost: say.handed.images.length
+			};
+		}
+	};
+	/** Forgets what was handed for `say`'s turn and those before, as the turn ends. */
+	const forgetHanded = async (say) => {
+		try {
+			await options.handed.forget(handedFor(say));
+		} catch (error) {
+			onEvent({
+				type: "problem",
+				message: `Couldn't let go of the images handed for chat ${say.chatId}: ${messageOf(error)}`
+			});
+		}
+	};
 	/** Runs one turn of `chat`, from its start to the report of its end. */
 	const turn = async (chat, say) => {
 		const underWay = {
@@ -7055,6 +8555,7 @@ function createChatRunner(options) {
 					usage: null
 				};
 			}
+			if (!killed) await forgetHanded(say);
 			if (!killed && !leaving) await reportEnded(underWay, answered.outcome, answered.usage);
 		} catch (error) {
 			onEvent({
@@ -7079,7 +8580,8 @@ function createChatRunner(options) {
 			sessionId: null,
 			instructions: null,
 			opened: false,
-			turns: Promise.resolve()
+			turns: Promise.resolve(),
+			said: 0
 		};
 		recalled.turns = recall(recalled, chatId);
 		chats.set(chatId, recalled);
@@ -7112,8 +8614,12 @@ function createChatRunner(options) {
 	return {
 		say(say) {
 			const chat = known(say.chatId);
+			chat.said = Math.max(chat.said, say.turn);
 			chat.turns = chat.turns.then(() => turn(chat, say));
 		},
+		whyNoImages(chatId, number) {
+			return number <= (chats.get(chatId)?.said ?? 0) ? `it took turn ${number} of this chat on already` : null;
+		},
 		async swept(workspace) {
 			const chatId = chatOfWorkspace(workspace);
 			if (chatId === null || killed) return;
@@ -7150,6 +8656,66 @@ function createChatRunner(options) {
 	};
 }
 //#endregion
+//#region src/image-uploads.ts
+/**
+* The Platform, or the image store, refused to take the images, which asking again won't change:
+* the message naming them goes as it is, and the Platform refuses it, saying why.
+*/
+var ImagesRefusedError = class extends Error {
+	name = "ImagesRefusedError";
+};
+/** How long one request may take before it's given up: a 10 MiB image on a slow line. */
+const REQUEST_TIMEOUT_MS = 3e5;
+/** Puts images into the image store of the Platform the Node joined with `credential`. */
+function platformImageUploads(credential) {
+	return async (images, signal) => {
+		for (const { image, bytes: read } of images) {
+			const bytes = await read();
+			const asked = { images: [{
+				key: image.key,
+				mimeType: image.mimeType,
+				bytes: bytes.length
+			}] };
+			const answered = await send(new URL(NODE_IMAGES_PATH, credential.platformUrl), signal, {
+				method: "POST",
+				headers: {
+					authorization: `Bearer ${credential.credential}`,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify(asked)
+			});
+			const [upload] = nodeImageUploadAnswer.parse(await answered.json()).uploads;
+			if (upload?.key !== image.key) throw new ImagesRefusedError(`The Platform named no place for image ${image.key}`);
+			if (upload.address) await send(new URL(upload.address.url, credential.platformUrl), signal, {
+				method: "PUT",
+				headers: { ...upload.address.headers },
+				body: bytes
+			});
+		}
+	};
+}
+/**
+* Sends one request, resolving with its answer once it succeeded. Rejects with an
+* `ImagesRefusedError` for a refusal (a 4xx), and an error of its own for anything that may pass
+* (no answer, a 5xx).
+*/
+async function send(url, signal, init) {
+	let response;
+	try {
+		response = await fetch(url, {
+			...init,
+			signal: AbortSignal.any([signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)])
+		});
+	} catch (error) {
+		throw new Error(`Couldn't reach ${url.origin}: ${messageOf(error)}`, { cause: error });
+	}
+	if (response.ok) return response;
+	const refusal = fetchRefusal.safeParse(await response.json().catch(() => null));
+	const reason = refusal.success ? refusal.data.error : `${url.origin} answered ${response.status}`;
+	if (response.status >= 400 && response.status < 500 && ![408, 429].includes(response.status)) throw new ImagesRefusedError(reason);
+	throw new Error(reason);
+}
+//#endregion
 //#region src/connector.ts
 function write(ws, message) {
 	ws.send(JSON.stringify(message));
@@ -7166,7 +8732,9 @@ function backoff(attempt) {
 /**
 * Dials out to the Platform (ADR-0006) and keeps the connection up: says hello, sends heartbeats,
 * replays the outbox after each welcome, and reconnects with backoff whenever the connection drops
-* or goes quiet for longer than the heartbeat timeout.
+* or goes quiet for longer than the heartbeat timeout. Its messages go one at a time, in the
+* outbox's order: one naming images waits until they are in the image store, put there from the
+* outbox (trying again with backoff while that fails), and every message after it waits behind it.
 */
 function connectToPlatform(options) {
 	const { credential, outbox, inbox, onEvent } = options;
@@ -7182,6 +8750,9 @@ function connectToPlatform(options) {
 	let heartbeatTimer;
 	let livenessTimer;
 	let sending = Promise.resolve();
+	let written = /* @__PURE__ */ new Set();
+	let delivering = Promise.resolve();
+	const ending = /* @__PURE__ */ new WeakMap();
 	let taking = Promise.resolve();
 	/** Who waits to hear what the Platform made of each message, by message id. */
 	const waitingForAck = /* @__PURE__ */ new Map();
@@ -7199,6 +8770,7 @@ function connectToPlatform(options) {
 	const open = () => {
 		const ws = new WebSocket(url, { headers: { authorization: `Bearer ${credential.credential}` } });
 		socket = ws;
+		ending.set(ws, new AbortController());
 		let refused = false;
 		expectWithin(ws, options.connectTimeoutMs);
 		ws.on("unexpected-response", (_request, response) => {
@@ -7209,7 +8781,7 @@ function connectToPlatform(options) {
 			write(ws, {
 				kind: "hello",
 				id: randomUUID(),
-				protocolVersion: 24,
+				protocolVersion: 25,
 				os: options.os
 			});
 		});
@@ -7217,6 +8789,7 @@ function connectToPlatform(options) {
 			if (ws === socket) receive(ws, textOf$1(data));
 		});
 		ws.on("close", (code, reason) => {
+			ending.get(ws)?.abort();
 			if (ws === socket) closed(refused ? NODE_CLOSE_CODES.refused : code, reason.toString());
 		});
 		ws.on("error", () => {});
@@ -7244,7 +8817,8 @@ function connectToPlatform(options) {
 					id: randomUUID()
 				}), message.heartbeatIntervalMs);
 				onEvent({ type: "connected" });
-				for (const pending of outbox.pending()) write(ws, pending);
+				written = /* @__PURE__ */ new Set();
+				deliver();
 				return;
 			case "ack":
 				acknowledged(message);
@@ -7368,15 +8942,72 @@ function connectToPlatform(options) {
 		});
 		reconnectTimer = setTimeout(open, options.reconnectDelayMs(attempt++));
 	};
-	const keepAndSend = async (message) => {
+	/** Whether `ws` is the connection, welcomed and open, that the outbox's messages go on now. */
+	const isUp = (ws) => ws !== null && ws === socket && welcomed && !stopping && ws.readyState === WebSocket.OPEN;
+	/** Writes what the outbox holds that the connection open now hasn't been sent, in order. */
+	const deliver = () => {
+		const ws = socket;
+		delivering = delivering.then(() => deliverOn(ws)).catch((error) => {
+			onEvent({
+				type: "problem",
+				message: `Couldn't send the outbox: ${messageOf(error)}`
+			});
+		});
+	};
+	const deliverOn = async (ws) => {
+		for (const message of outbox.pending()) {
+			if (!isUp(ws)) return;
+			if (written.has(message.id)) continue;
+			if (imagesNamedBy(message).length > 0 && !await imagesPutFor(ws, message)) return;
+			if (!isUp(ws)) return;
+			written.add(message.id);
+			write(ws, message);
+		}
+	};
+	/**
+	* Puts the images `message` names into the image store, trying again with backoff while that
+	* fails and `ws` is up. Resolves with whether to send it now: false once `ws` went down, which
+	* stops it. Images the image store refuses outright, or no longer kept here, can't be put there by
+	* trying again: the message goes as it is, for the Platform to refuse with its reason.
+	*/
+	const imagesPutFor = async (ws, message) => {
+		const images = imagesNamedBy(message).map((image) => ({
+			image,
+			bytes: () => outbox.image(image.key)
+		}));
+		const signal = ending.get(ws)?.signal ?? AbortSignal.abort();
+		for (let tries = 0;; tries++) {
+			try {
+				await options.uploadImages(images, signal);
+				return true;
+			} catch (error) {
+				if (!isUp(ws)) return false;
+				const lost = error instanceof Error && "code" in error && error.code === "ENOENT";
+				if (error instanceof ImagesRefusedError || lost) {
+					onEvent({
+						type: "problem",
+						message: `The images of a ${message.kind} couldn't be put into the image store: ${messageOf(error)}`
+					});
+					return true;
+				}
+				onEvent({
+					type: "problem",
+					message: `Couldn't put the images of a ${message.kind} into the image store yet: ${messageOf(error)}`
+				});
+			}
+			await setTimeout$1(options.reconnectDelayMs(tries), null, { signal }).catch(() => null);
+			if (!isUp(ws)) return false;
+		}
+	};
+	const keepAndSend = async (message, images) => {
 		if (killed) return;
-		await outbox.add(message);
-		if (welcomed && socket && !stopping) write(socket, message);
+		await outbox.add(message, images);
+		if (isUp(socket)) deliver();
 	};
 	open();
 	return {
-		send(message) {
-			const sent = sending.then(() => keepAndSend(message));
+		send(message, images) {
+			const sent = sending.then(() => keepAndSend(message, images));
 			sending = sent.catch(() => {});
 			return sent;
 		},
@@ -7426,11 +9057,11 @@ function connectToPlatform(options) {
 const FETCH_TIMEOUT_MS = 6e4;
 /** The Platform's documents, as the Node that joined with `credential` may read them. */
 function platformDocuments(credential) {
-	const get = async (path) => {
+	const get = async (path, headers = { authorization: `Bearer ${credential.credential}` }) => {
 		let response;
 		try {
 			response = await fetch(new URL(path, credential.platformUrl), {
-				headers: { authorization: `Bearer ${credential.credential}` },
+				headers,
 				signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
 			});
 		} catch (error) {
@@ -7444,7 +9075,10 @@ function platformDocuments(credential) {
 	};
 	return {
 		handOff: async (taskId, handOffId) => fetchedHandOff.parse(await (await get(nodeHandOffPath(taskId, handOffId))).json()),
-		image: async (taskId, handOffId, index) => new Uint8Array(await (await get(nodeHandOffImagePath(taskId, handOffId, index))).arrayBuffer())
+		brief: async (taskId) => fetchedBrief.parse(await (await get(nodeBriefPath(taskId))).json()),
+		verdicts: async (taskId) => fetchedVerdicts.parse(await (await get(nodeVerdictsPath(taskId))).json()),
+		annotations: async (taskId, checkId) => fetchedAnnotations.parse(await (await get(nodeAnnotationsPath(taskId, checkId))).json()),
+		image: async (address) => new Uint8Array(await (await get(address.url, { ...address.headers })).arrayBuffer())
 	};
 }
 //#endregion
@@ -7480,11 +9114,11 @@ async function thisInstallation() {
 * `reason`. Asks npm for its latest when that may help.
 */
 async function protocolMove(installed, platformVersion, reason) {
-	if (platformVersion === null || platformVersion === 24) return {
+	if (platformVersion === null || platformVersion === 25) return {
 		kind: "unreadable",
 		reason
 	};
-	if (platformVersion < 24) return {
+	if (platformVersion < 25) return {
 		kind: "wait-for-platform",
 		platformVersion
 	};
@@ -7589,6 +9223,119 @@ function quietNpm(env) {
 	};
 }
 //#endregion
+//#region src/handed-images.ts
+/** An image being handed is written aside under this name until its last part came. */
+const PARTIAL = ".partial";
+/** The folder of what is handed for `to`, in the Node's own: by what it is for, never a path. */
+function folderFor(dir, to) {
+	return to.of === "reply" ? join(dir, `reply-${to.taskId}`) : join(chatFolder(dir, to.chatId), String(to.turn));
+}
+/** The folder of what is handed for chat `chatId`'s turns, a folder per turn in it. */
+function chatFolder(dir, chatId) {
+	return join(dir, `chat-${chatId}`);
+}
+/**
+* Opens the images handed to this Node, kept in `dir`: what was handed for replies to the daemon
+* before goes first.
+*/
+async function openHandedImages(options) {
+	const { dir } = options;
+	await mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	for (const folder of await readdir(dir)) if (folder.startsWith("reply-")) await rm(join(dir, folder), {
+		recursive: true,
+		force: true
+	});
+	return {
+		async take(part) {
+			const why = options.accepts(part.to);
+			if (why !== null) return {
+				kind: "refused",
+				why
+			};
+			const bytes = Buffer.from(part.data, "base64");
+			if (part.at + bytes.length > IMAGE_LIMITS.bytes) return {
+				kind: "refused",
+				why: `image ${part.index + 1} is larger than ${IMAGE_LIMITS.bytes / 1024 / 1024} MiB`
+			};
+			const folder = join(folderFor(dir, part.to), part.handing);
+			const file = join(folder, `${part.index}${PARTIAL}`);
+			if (part.at === 0) {
+				if (imageTypeOf(bytes) !== part.mimeType) return {
+					kind: "refused",
+					why: `image ${part.index + 1} isn't the ${part.mimeType} it says`
+				};
+				await mkdir(folder, {
+					recursive: true,
+					mode: 448
+				});
+				await writeFile(file, bytes, { mode: 384 });
+			} else {
+				if (await sizeOf(file) !== part.at) return {
+					kind: "refused",
+					why: `a part of image ${part.index + 1} came out of place`
+				};
+				await appendFile(file, bytes);
+			}
+			if (part.last) await rename(file, join(folder, String(part.index)));
+			return { kind: "taken" };
+		},
+		async claim(to, { handing, images }, workspace, beside) {
+			const folder = join(folderFor(dir, to), handing);
+			for (const index of images.keys()) if (await sizeOf(join(folder, String(index))) < 0) throw new Error(`Image ${index + 1} wasn't handed to this Node whole`);
+			const written = await writeImages(workspace, beside, images, (index) => readFile(join(folder, String(index))));
+			await forget(dir, to);
+			return written;
+		},
+		forget: (to) => forget(dir, to),
+		async sweep(before) {
+			for (const chat of await readdir(dir)) {
+				if (!chat.startsWith("chat-")) continue;
+				const folder = join(dir, chat);
+				for (const turn of await readdir(folder)) if ((await stat(join(folder, turn))).mtimeMs < before) await rm(join(folder, turn), {
+					recursive: true,
+					force: true
+				});
+				if ((await readdir(folder)).length === 0 && (await stat(folder)).mtimeMs < before) await rm(folder, {
+					recursive: true,
+					force: true
+				});
+			}
+		}
+	};
+}
+/** Forgets what is handed in `dir` for `to`: a chat's for its turns up to `to`'s. */
+async function forget(dir, to) {
+	if (to.of === "reply") {
+		await rm(folderFor(dir, to), {
+			recursive: true,
+			force: true
+		});
+		return;
+	}
+	const folder = chatFolder(dir, to.chatId);
+	let turns;
+	try {
+		turns = await readdir(folder);
+	} catch {
+		return;
+	}
+	for (const turn of turns) if (Number(turn) <= to.turn) await rm(join(folder, turn), {
+		recursive: true,
+		force: true
+	});
+}
+/** How many bytes the file at `path` holds, or -1 when there is none. */
+async function sizeOf(path) {
+	try {
+		return (await stat(path)).size;
+	} catch {
+		return -1;
+	}
+}
+//#endregion
 //#region src/own-setup.ts
 /** What else `runtime` reads on `machine`, for a Session in a Workspace in `workspacesDir`. */
 async function ownSetupOf(runtime, machine, workspacesDir) {
@@ -8019,6 +9766,86 @@ function answerOf(found) {
 	};
 }
 //#endregion
+//#region src/question-images.ts
+/** Where a question's or a reply's images were written, as the Node files it. */
+const filedImages = z.object({
+	/** The Workspace they are in. */
+	workspace: z.string().min(1),
+	/** Each image, in the question's order: its file from the Workspace's root, and its type. */
+	images: z.array(z.object({
+		path: z.string().min(1),
+		mimeType: imageType
+	}))
+});
+/** Where the Node files question `question` of Task `taskId` among its Sessions. */
+function filedAt(sessionsDir, taskId, question) {
+	return join(sessionsDir, taskId, "help-requests", `${question}.json`);
+}
+/** Where the Node files the images of the reply to Task `taskId` that `handing` brought. */
+function replyFiledAt(sessionsDir, taskId, handing) {
+	return join(sessionsDir, taskId, "help-replies", `${handing}.json`);
+}
+/** Files `images`, written into `workspace`, at `filed`. */
+async function fileImages(filed, workspace, images) {
+	await mkdir(join(filed, ".."), {
+		recursive: true,
+		mode: 448
+	});
+	await writeAtomically(filed, JSON.stringify({
+		workspace,
+		images: images.map(({ path, mimeType }) => ({
+			path,
+			mimeType
+		}))
+	}));
+}
+/** Image `index` of those filed at `filed`, from their Workspace. */
+async function filedImage(filed, index) {
+	const text = await readFile(filed, "utf8").catch((error) => {
+		if (isMissing$1(error)) return null;
+		throw error;
+	});
+	const parsed = text === null ? null : filedImages.safeParse(jsonIn(text));
+	const named = parsed?.success ? parsed.data.images[index] : void 0;
+	if (!parsed?.success || named === void 0) return {
+		kind: "missing",
+		why: "it keeps no such image"
+	};
+	return imageInWorkspace(parsed.data.workspace, named.path);
+}
+/**
+* Copies the images an Agent asked with into its Workspace, as they are now, and files where they
+* are under `asking`'s ids. Returns them as the `help-request` message names them: without their
+* bytes.
+*/
+async function keepQuestionImages(asking, images) {
+	const about = images.map(({ mimeType, alt }) => ({
+		mimeType,
+		...alt === void 0 ? {} : { alt }
+	}));
+	if (images.length === 0) return about;
+	const written = await writeImages(asking.workspace, {
+		folder: posix.join(WORKSPACE_FOLDERS.helpRequest, String(asking.number)),
+		stem: "question"
+	}, about, async (index) => images[index]?.bytes ?? Buffer.alloc(0));
+	await fileImages(filedAt(asking.sessionsDir, asking.taskId, asking.question), asking.workspace, about.map(({ mimeType }, index) => ({
+		path: written[index]?.path ?? "",
+		mimeType
+	})));
+	return about;
+}
+/** Files where the images a reply came with were written in its Task's Workspace (`written`). */
+async function fileReplyImages(replying, written) {
+	await fileImages(replyFiledAt(replying.sessionsDir, replying.taskId, replying.handing), replying.workspace, written);
+}
+/**
+* One image of a Help Request's question or reply, from its Task's Workspace, by the ids it is
+* filed under.
+*/
+async function helpRequestImage(sessionsDir, image) {
+	return filedImage(image.of === "help-request" ? filedAt(sessionsDir, image.taskId, image.question) : replyFiledAt(sessionsDir, image.taskId, image.handing), image.index);
+}
+//#endregion
 //#region src/requests.ts
 /** The most bytes of JSON one part of an answer holds: well inside one message of the Node link. */
 const PART_BYTES = 1048576;
@@ -8027,10 +9854,11 @@ const PROBE_MARGIN_MS = 2e3;
 /** Answers each request the Platform sends, in the background. */
 function answerRequests(options) {
 	const answer = async (request) => {
-		const giveUpAt = Date.now() + request.timeoutMs;
+		let giveUpAt = Date.now() + request.timeoutMs;
 		const parts = await answerTo(request);
 		for (const [part, piece] of parts.entries()) {
 			if (Date.now() > giveUpAt) return;
+			giveUpAt = Date.now() + request.timeoutMs;
 			if (!options.send({
 				kind: "answer",
 				id: randomUUID(),
@@ -8046,6 +9874,8 @@ function answerRequests(options) {
 		const { ask } = request;
 		if (ask.about === "session-record") return recordOf(ask.session);
 		if (ask.about === "repository-probe") return probeOf(ask.repository, request.timeoutMs, options.signal);
+		if (ask.about === "image") return imageOf(ask.image);
+		if (ask.about === "handed-image") return handedPart(ask);
 		return setupOf(ask.runtime, ask.of === "millwright" ? options.millwrightDir : options.workspacesDir);
 	};
 	/**
@@ -8065,6 +9895,53 @@ function answerRequests(options) {
 			}];
 		}
 	};
+	/** An image it keeps: its bytes, in parts, or why it can't send them. */
+	const imageOf = async (image) => {
+		let kept;
+		try {
+			kept = image.of === "session-record" ? await recordImageOf(recordFolder(options.sessionsDir, image.session), image) : await helpRequestImage(options.sessionsDir, image);
+		} catch (error) {
+			return [{
+				kind: "failed",
+				reason: `${options.name} couldn't read the image: ${messageOf(error)}`.slice(0, 2e3)
+			}];
+		}
+		if (kept.kind === "gone") return [{
+			kind: "gone",
+			reason: `${options.name} cleaned up the Workspace it kept the image in, and the image went with it`.slice(0, 500)
+		}];
+		if (kept.kind === "missing") return [{
+			kind: "refused",
+			reason: `${options.name} can't send the image: ${kept.why}`.slice(0, 500)
+		}];
+		const { mimeType, bytes } = kept;
+		const parts = [];
+		for (let at = 0; at < bytes.length; at += IMAGE_PART_BYTES) {
+			const data = bytes.subarray(at, at + IMAGE_PART_BYTES).toString("base64");
+			parts.push({
+				kind: "image",
+				mimeType,
+				data
+			});
+		}
+		return parts;
+	};
+	/** A part of an image the Platform hands it: on disk once answered, or why it isn't. */
+	const handedPart = async (part) => {
+		try {
+			const taken = await options.handed.take(part);
+			if (taken.kind === "refused") return [{
+				kind: "refused",
+				reason: `${options.name} can't take the images: ${taken.why}`.slice(0, 500)
+			}];
+			return [{ kind: "handed-image" }];
+		} catch (error) {
+			return [{
+				kind: "failed",
+				reason: `${options.name} couldn't keep the images: ${messageOf(error)}`.slice(0, 2e3)
+			}];
+		}
+	};
 	/** `session`'s record: its items, in parts. */
 	const recordOf = async (session) => {
 		const folder = recordFolder(options.sessionsDir, session);
@@ -8131,24 +10008,32 @@ function partsOf(items) {
 }
 //#endregion
 //#region src/factory-mcp.ts
+/** The images an Agent names in a tool call, by their paths in its Workspace, `described` so. */
+function imagesInput(described) {
+	return z.array(z.object({
+		path: z.string().min(1).describe("An image file in your Workspace."),
+		alt: z.string().max(IMAGE_LIMITS.alt).optional().describe("What the image shows.")
+	})).max(IMAGE_LIMITS.images).optional().describe(described);
+}
 /** What the Agent passes to the hand-off tool. */
 const handOffInput = z.object({
 	markdown: z.string().describe("Your Hand-off, a document in Markdown: what you did, what you found, and what whoever reads it next needs to know."),
-	images: z.array(z.object({
-		path: z.string().min(1).describe("An image file in your Workspace."),
-		alt: z.string().max(500).optional().describe("What the image shows.")
-	})).max(HAND_OFF_LIMITS.images).optional().describe("Small images that belong in the document, such as a screenshot."),
+	images: imagesInput("Images that belong in the document, such as a screenshot."),
 	references: z.array(handOffReference).max(HAND_OFF_LIMITS.references).optional().describe("Materials you produced, where they live: a label, and a URL or a pinned identifier (a pushed commit, say).")
 });
 /** What the Agent passes to the help tool. */
-const helpInput = z.object({ question: z.string().describe("Your question for the Owner, in Markdown: what you need to know, and what you found that makes you ask.") });
+const helpInput = z.object({
+	question: z.string().describe("Your question for the Owner, in Markdown: what you need to know, and what you found that makes you ask."),
+	images: imagesInput("Images that show the Owner what you see, such as a screenshot: they see them as they are when you ask.")
+});
 /**
 * What the Inspector passes to the check tool: one flat object, as some CLIs want a tool's input
 * to be, which `judgementFrom` makes a judgement of.
 */
 const judgeInput = z.object({
 	outcome: z.enum(["passed", "failed"]).describe("Whether the Hand-off meets every one of the Belt's criteria."),
-	annotations: z.string().optional().describe("When it failed: which criteria the Hand-off doesn't meet and why, in Markdown. Required then.")
+	annotations: z.string().optional().describe("When it failed: which criteria the Hand-off doesn't meet and why, in Markdown. Required then."),
+	images: imagesInput("When it failed: images that show what is wrong, such as a screenshot, beside the annotations.")
 });
 /** A tool's input schema, as JSON Schema. */
 function jsonSchemaOf(schema) {
@@ -8166,7 +10051,10 @@ async function serveFactoryMcp(options) {
 			name: JUDGE_TOOL,
 			description: `Records your judgement of the Hand-off under check. ${JUDGE_GUIDANCE}`,
 			inputSchema: jsonSchemaOf(judgeInput),
-			handler: async (input) => options.judge(judgementFrom(input))
+			handler: async (input) => {
+				const { judgement: made, images } = await judgementFrom(options.workspace, input);
+				return options.judge(made, images);
+			}
 		}]
 	});
 	return serveMcpTools({
@@ -8176,89 +10064,126 @@ async function serveFactoryMcp(options) {
 			name: HAND_OFF_TOOL,
 			description: `Delivers your finished work as a Hand-off. ${HAND_OFF_GUIDANCE}`,
 			inputSchema: jsonSchemaOf(handOffInput),
-			handler: async (input) => options.handOff(await handOffFrom(options.workspace, input))
+			handler: async (input) => {
+				const { document, images } = await handOffFrom(options.workspace, input);
+				return options.handOff(document, images);
+			}
 		}, {
 			name: HELP_TOOL,
 			description: `Asks the Owner a question when you're stuck. ${HELP_GUIDANCE}`,
 			inputSchema: jsonSchemaOf(helpInput),
-			handler: async (input) => options.askForHelp(questionFrom(input))
+			handler: async (input) => {
+				const { question, images } = questionFrom(input);
+				return options.askForHelp(question, await imagesIn(options.workspace, images, "question"));
+			}
 		}]
 	});
 }
-/** The question the Agent asked, or an error saying what's wrong with it, for the Agent. */
+/**
+* The question the Agent asked, and the images it named with it, or an error saying what's wrong
+* with it, for the Agent.
+*/
 function questionFrom(input) {
 	const asked = helpInput.safeParse(input);
 	if (!asked.success) throw new Error(`That isn't a question for the Owner: ${z.prettifyError(asked.error)}`);
 	const question = helpQuestion.safeParse(asked.data.question);
 	if (!question.success) throw new Error(`That isn't a question for the Owner: ${z.prettifyError(question.error)}`);
-	return question.data;
+	return {
+		question: question.data,
+		images: asked.data.images ?? []
+	};
 }
-/** The judgement the Inspector asked for, or an error saying what's wrong with it, for it. */
-function judgementFrom(input) {
+/**
+* The judgement the Inspector asked for, with the images a failed one names read from its
+* Workspace, or an error saying what's wrong with it, for it. A passing judgement carries no
+* annotations or images: whatever it names is never read.
+*/
+async function judgementFrom(workspace, input) {
 	const asked = judgeInput.safeParse(input);
 	if (!asked.success) throw new Error(`That isn't a judgement: ${z.prettifyError(asked.error)}`);
 	const { outcome, annotations } = asked.data;
 	if (outcome === "failed" && !annotations?.trim()) throw new Error("A Hand-off that failed needs annotations: say which criteria it doesn't meet and why.");
+	const images = outcome === "failed" ? await imagesIn(workspace, asked.data.images ?? [], "annotations") : [];
 	const made = judgement.safeParse(outcome === "failed" ? {
 		outcome,
-		annotations
+		annotations,
+		images: images.map(documentImageOf)
 	} : { outcome: "passed" });
 	if (!made.success) throw new Error(`That isn't a judgement: ${z.prettifyError(made.error)}`);
-	return made.data;
+	return {
+		judgement: made.data,
+		images
+	};
 }
-/** The Hand-off the Agent asked for, or an error saying what's wrong with it, for the Agent. */
+/**
+* The Hand-off the Agent asked for, with the images it names read from its Workspace, or an error
+* saying what's wrong with it, for the Agent.
+*/
 async function handOffFrom(workspace, input) {
 	const asked = handOffInput.safeParse(input);
 	if (!asked.success) throw new Error(`That isn't a Hand-off: ${z.prettifyError(asked.error)}`);
-	const images = await Promise.all((asked.data.images ?? []).map((image) => imageFrom(workspace, image.path, image.alt)));
+	const images = await imagesIn(workspace, asked.data.images ?? [], "hand-off");
 	const made = handOff.safeParse({
 		markdown: asked.data.markdown,
-		images,
+		images: images.map(documentImageOf),
 		references: asked.data.references ?? []
 	});
 	if (!made.success) throw new Error(`That isn't a Hand-off: ${z.prettifyError(made.error)}`);
-	return made.data;
+	return {
+		document: made.data,
+		images
+	};
 }
-/** Reads an image for a Hand-off from the Workspace. */
-async function imageFrom(workspace, path, alt) {
-	let file;
-	try {
-		file = await realpath(resolve(workspace, path));
-	} catch {
-		throw new Error(`There's no image at ${path} in your Workspace.`);
-	}
-	const fromRoot = relative(await realpath(workspace), file);
-	if (fromRoot.startsWith("..") || isAbsolute(fromRoot)) throw new Error(`${path} isn't in your Workspace: a Hand-off's images must be.`);
-	if ((await stat(file)).size > HAND_OFF_LIMITS.imageBytes) throw new Error(`${path} is larger than ${HAND_OFF_LIMITS.imageBytes / 1024} KiB. A Hand-off is a document: make the image smaller, or put it somewhere reachable and reference it.`);
-	const bytes = await readFile(file);
-	const mimeType = imageTypeOf(bytes);
-	if (!mimeType) throw new Error(`${path} isn't a PNG, JPEG, GIF or WebP image.`);
+/** How a document names an image the Agent named: its key in the image store, type and alt. */
+function documentImageOf({ key, mimeType, alt }) {
 	return {
+		key,
 		mimeType,
-		data: bytes.toString("base64"),
 		...alt === void 0 ? {} : { alt }
 	};
 }
-/** An image's type, from its first bytes. */
-function imageTypeOf(bytes) {
-	if (bytes.subarray(0, 8).equals(Buffer.from([
-		137,
-		80,
-		78,
-		71,
-		13,
-		10,
-		26,
-		10
-	]))) return "image/png";
-	if (bytes.subarray(0, 3).equals(Buffer.from([
-		255,
-		216,
-		255
-	]))) return "image/jpeg";
-	if (bytes.subarray(0, 4).toString("latin1") === "GIF8") return "image/gif";
-	if (bytes.subarray(0, 4).toString("latin1") === "RIFF" && bytes.subarray(8, 12).toString("latin1") === "WEBP") return "image/webp";
-	return null;
+/** What a tool's images are for, in the words that refuse one. */
+const IMAGES_FOR = {
+	"hand-off": {
+		whose: "a Hand-off's",
+		tooLarge: "A Hand-off is a document: make the image smaller, or put it somewhere reachable and reference it."
+	},
+	question: {
+		whose: "a question's",
+		tooLarge: "Make the image smaller: the Owner sees it as it is."
+	},
+	annotations: {
+		whose: "annotations'",
+		tooLarge: "Make the image smaller: whoever reworks the Hand-off sees it as it is."
+	}
+};
+/**
+* Reads the images an Agent `named` in a tool call (its Hand-off, its question, or its annotations)
+* from its `workspace`, in order; rejects with why one can't be, in words for the Agent.
+*/
+async function imagesIn(workspace, named, forWhat) {
+	return Promise.all(named.map(({ path, alt }) => imageIn(workspace, path, alt, forWhat)));
+}
+/**
+* Reads one image the Agent named from its Workspace (`readWorkspaceImage`, the one way images are
+* read there), refusing one it can't take in words for the Agent.
+*/
+async function imageIn(workspace, path, alt, forWhat) {
+	const words = IMAGES_FOR[forWhat];
+	const read = await readWorkspaceImage(workspace, path);
+	if (read.kind === "image") {
+		const { mimeType, bytes } = read;
+		return {
+			key: createHash("sha256").update(bytes).digest("hex"),
+			mimeType,
+			bytes,
+			alt
+		};
+	}
+	if (read.kind === "outside") throw new Error(`${path} isn't in your Workspace: ${words.whose} images must be.`);
+	if (read.kind === "too-large") throw new Error(`${path} is larger than ${IMAGE_LIMITS.bytes / 1024 / 1024} MiB. ${words.tooLarge}`);
+	if (read.kind === "not-an-image") throw new Error(`${path} isn't a PNG, JPEG, GIF or WebP image.`);
+	throw new Error(`There's no image at ${path} in your Workspace.`);
 }
 //#endregion
 //#region src/tasks.ts
@@ -8359,7 +10284,9 @@ function added(a, b) {
 * through the Runtime driver. A Workstation Task's work hands off, or asks the Owner for help: its
 * turn ends, the Task is kept suspended with its Workspace and Session id, and the Owner's reply
 * resumes that Session there, in a new segment with the same instructions, a Factory MCP of its own
-* and its Agent's Skills as the reply names them (#120), readied anew. A check of its Hand-off
+* and its Agent's Skills as the reply names them (#120), readied anew; the images the reply came
+* with (#186), which the Platform handed the Node before (handed-images.ts), are written into the
+* Workspace beside the question and come inside the prompt that resumes it. A check of its Hand-off
 * records the Inspector's judgement (ADR-0014). The Platform hears
 * through the connector's outbox that the Session started (each segment), the Hand-off, the
 * question or the judgement, and how the Session ended with the tokens it used, its segments'
@@ -8447,9 +10374,12 @@ function createTaskRunner(options) {
 		}, options.handOffGraceMs);
 		now.done.finally(() => clearTimeout(grace));
 	};
-	/** Puts `message` in the outbox, keeping the call until it is there. */
-	const keep = async (message) => {
-		const kept = connector.send(message);
+	/**
+	* Puts `message` in the outbox, with the bytes of the images it names, keeping the call until it
+	* is there.
+	*/
+	const keep = async (message, images = []) => {
+		const kept = connector.send(message, images);
 		keeping.add(kept);
 		try {
 			await kept;
@@ -8458,13 +10388,16 @@ function createTaskRunner(options) {
 		}
 	};
 	/**
-	* Relays what the Agent's tool call made (a Hand-off, or a judgement) and tells the Agent what
-	* became of it.
+	* Relays what the Agent's tool call made (a Hand-off, or a judgement), with the images it names,
+	* and tells the Agent what became of it.
 	*/
-	const relay = async (session, agent, message) => {
+	const relay = async (session, agent, message, images = []) => {
 		const acknowledged = connector.acknowledgement(message.id);
 		stopAfterGrace(session, agent, message.kind === "hand-off" ? "handing off" : "judging", acknowledged);
-		await keep(message);
+		await keep(message, images.map(({ key, bytes }) => ({
+			key,
+			bytes
+		})));
 		const waited = new AbortController();
 		const ack = await Promise.race([acknowledged, setTimeout$1(options.handOffWaitMs, null, { signal: waited.signal }).catch(() => null)]);
 		waited.abort();
@@ -8474,8 +10407,8 @@ function createTaskRunner(options) {
 		if (ack.outcome === "refused") throw new Error(`The Platform didn't take this ${what}: ${ack.reason ?? "no reason given"}`);
 		return `Your ${what} reached the Platform. Your ${done} is done: stop here.`;
 	};
-	/** Relays the Agent's Hand-off. */
-	const handOff = (session, agent, document) => {
+	/** Relays the Agent's Hand-off, with the images it names. */
+	const handOff = (session, agent, document, images) => {
 		const id = randomUUID();
 		return relay(session, agent, {
 			kind: "hand-off",
@@ -8483,10 +10416,10 @@ function createTaskRunner(options) {
 			idempotencyKey: `hand-off:${session.taskId}:${id}`,
 			taskId: session.taskId,
 			handOff: document
-		});
+		}, images);
 	};
-	/** Relays the Inspector's judgement. */
-	const judge = (session, inspector, judgement) => {
+	/** Relays the Inspector's judgement, with the images a failed one names. */
+	const judge = (session, inspector, judgement, images) => {
 		const id = randomUUID();
 		return relay(session, inspector, {
 			kind: "judgement",
@@ -8495,17 +10428,32 @@ function createTaskRunner(options) {
 			taskId: session.taskId,
 			checkId: session.checkId,
 			judgement
-		});
+		}, images);
 	};
 	/**
 	* Sends the Owner the Agent's question (spec stories 56 and 57): once it is in the outbox, the
 	* tool returns at once, telling the Agent to end its turn (ADR-0009). One question per segment:
-	* the reply to it starts the next.
+	* the reply to it starts the next. The images it asks with are copied into its Workspace first,
+	* as they are now (#185, question-images.ts), and its message names them without their bytes.
 	*/
-	const askForHelp = async (work, asking, question) => {
+	const askForHelp = async (work, asking, question, images) => {
 		if (asking.asked) throw new Error("You asked the Owner already: end your turn now. Their reply will continue this Session.");
 		asking.asked = true;
 		const id = randomUUID();
+		const { taskId } = work.session;
+		let kept;
+		try {
+			kept = await keepQuestionImages({
+				sessionsDir: options.sessionsDir,
+				taskId,
+				question: id,
+				number: work.segments,
+				workspace: work.workspace
+			}, images);
+		} catch (error) {
+			asking.asked = false;
+			throw new Error(`Couldn't keep your images on this machine: ${messageOf(error)}`, { cause: error });
+		}
 		const acknowledged = connector.acknowledgement(id);
 		stopAfterGrace(work.session, work.task.agent.name, "asking for help", acknowledged, () => {
 			asking.stoppedAfter = true;
@@ -8514,9 +10462,10 @@ function createTaskRunner(options) {
 			await keep({
 				kind: "help-request",
 				id,
-				idempotencyKey: `help-request:${work.session.taskId}:${id}`,
-				taskId: work.session.taskId,
-				question
+				idempotencyKey: `help-request:${taskId}:${id}`,
+				taskId,
+				question,
+				images: kept
 			});
 		} catch (error) {
 			asking.asked = false;
@@ -8549,6 +10498,10 @@ function createTaskRunner(options) {
 		const skills = skillsHeldBy.get(keyOf(session));
 		skillsHeldBy.delete(keyOf(session));
 		if (skills !== void 0 && !killed) await skills();
+		if (session.role === "work" && !killed) await options.handed.forget({
+			of: "reply",
+			taskId: session.taskId
+		});
 	};
 	/**
 	* Opens a Session for `session` in `workspace` (or resumes the one `resume` names there) with the
@@ -8631,17 +10584,18 @@ function createTaskRunner(options) {
 		const agent = task.agent.name;
 		const factory = await serveFactoryMcp({
 			role: "check",
-			judge: (judgement) => judge(session, agent, judgement)
+			workspace,
+			judge: (judgement, images) => judge(session, agent, judgement, images)
 		});
 		let segment;
 		try {
 			segment = await runSession(session, {
 				task,
 				workspace,
-				instructions: instructionsFor(task, files),
+				instructions: instructionsFor(task, workspace, files),
 				skills,
 				factory,
-				prompt: promptFor(task),
+				prompt: promptFor(task, files),
 				startedKey: keyFor("task-started", session)
 			}, stop);
 		} finally {
@@ -8650,8 +10604,8 @@ function createTaskRunner(options) {
 		await reportEnd(session, segment.outcome, segment.usage ?? null);
 	};
 	/**
-	* Runs the next segment of a Task's work: its first, with the Task's prompt, or one resuming its
-	* Session with the Owner's reply. Then, if its Agent asked the Owner for help and ended its turn,
+	* Runs the next segment of a Task's work: its first, with the Task's prompt (the brief's images
+	* inside it, #181), or one resuming its Session with the Owner's reply. Then, if its Agent asked the Owner for help and ended its turn,
 	* the Task is suspended (or goes straight on, if the reply came meanwhile); otherwise its end is
 	* reported, with the tokens of all its segments.
 	*/
@@ -8669,8 +10623,8 @@ function createTaskRunner(options) {
 		const factory = await serveFactoryMcp({
 			role: "work",
 			workspace,
-			handOff: (document) => handOff(session, agent, document),
-			askForHelp: (question) => askForHelp(work, asking, question)
+			handOff: (document, images) => handOff(session, agent, document, images),
+			askForHelp: (question, images) => askForHelp(work, asking, question, images)
 		});
 		let segment;
 		try {
@@ -8763,6 +10717,46 @@ function createTaskRunner(options) {
 		if (before !== void 0 && !killed) await before();
 		return true;
 	};
+	/**
+	* The images `reply` came with (#186), written into its Task's Workspace beside the question it
+	* answers (`help-request/<n>/reply-1.png`…, n the asking segment's number, as the question's own),
+	* from where the Platform handed them; or how many of them there were, when they couldn't be.
+	*/
+	const replyImagesOf = async (work, { handed }) => {
+		if (handed === void 0) return {
+			written: [],
+			lost: 0
+		};
+		const { taskId } = work.session;
+		try {
+			const written = await options.handed.claim({
+				of: "reply",
+				taskId
+			}, handed, work.workspace, {
+				folder: posix.join(WORKSPACE_FOLDERS.helpRequest, String(work.segments)),
+				stem: "reply"
+			});
+			await fileReplyImages({
+				sessionsDir: options.sessionsDir,
+				taskId,
+				handing: handed.handing,
+				workspace: work.workspace
+			}, written);
+			return {
+				written,
+				lost: 0
+			};
+		} catch (error) {
+			onEvent({
+				type: "problem",
+				message: `Couldn't write the images of the reply to Task ${taskId} into its Workspace: ${messageOf(error)}`
+			});
+			return {
+				written: [],
+				lost: handed.images.length
+			};
+		}
+	};
 	/** Resumes a Task's work with the Owner's reply, in a new segment, in the background. */
 	const goOn = (work, reply) => {
 		if (stopping || killed) {
@@ -8784,7 +10778,10 @@ function createTaskRunner(options) {
 					await options.underWay.remove(kept);
 				}
 			}
-			if (await readyForReply(work, reply, stop)) await workSegment(work, replyPromptFor(work.task, reply.reply), stop);
+			if (await readyForReply(work, reply, stop)) {
+				const images = await replyImagesOf(work, reply);
+				await workSegment(work, replyPromptFor(work.task, reply.reply, images), stop);
+			}
 		}, () => work.usage ?? null);
 	};
 	/** Runs a Session the Platform sent, from its new Workspace on. */
@@ -8825,7 +10822,10 @@ function createTaskRunner(options) {
 		try {
 			files = {
 				workpiece: await writeWorkpiece(workspace, task, options.documents),
-				...task.role === "check" ? { underCheck: await writeHandOffUnderCheck(workspace, task, options.documents) } : { previous: await writePreviousAttempt(workspace, task, options.documents) }
+				...task.role === "check" ? { underCheck: await writeHandOffUnderCheck(workspace, task, options.documents) } : {
+					previous: await writePreviousAttempt(workspace, task, options.documents),
+					verdicts: await writeVerdictImages(workspace, task, options.documents)
+				}
 			};
 		} catch (error) {
 			await reportEnd(session, {
@@ -8851,7 +10851,7 @@ function createTaskRunner(options) {
 				taskId
 			},
 			workspace,
-			instructions: instructionsFor(task, files),
+			instructions: instructionsFor(task, workspace, files),
 			skills: readied.skills,
 			state: "running",
 			sessionId: null,
@@ -8863,7 +10863,7 @@ function createTaskRunner(options) {
 			saved: Promise.resolve()
 		};
 		works.set(taskId, work);
-		await workSegment(work, promptFor(task), stop);
+		await workSegment(work, promptFor(task, files), stop);
 	};
 	/** Ends every Session still running, and waits for what is on its way into the outbox. */
 	const stopAll = async () => {
@@ -8879,19 +10879,21 @@ function createTaskRunner(options) {
 			if (running.has(keyOf(session)) || session.role === "work" && works.has(session.taskId)) return;
 			inBackground(session, (stop) => run(task, stop), () => works.get(session.taskId)?.usage ?? null);
 		},
-		resume({ taskId, reply, skills }) {
+		resume({ taskId, reply, skills, handed }) {
 			const work = works.get(taskId);
 			if (work?.state === "suspended") {
 				goOn(work, {
 					reply,
-					skills
+					skills,
+					handed
 				});
 				return;
 			}
 			if (work) {
 				work.reply = {
 					reply,
-					skills
+					skills,
+					handed
 				};
 				return;
 			}
@@ -8990,6 +10992,11 @@ function createTaskRunner(options) {
 				ending(reportEnd(ref, { kind: "aborted" }, left.suspended.usage, left.item));
 			}
 		},
+		whyNoReply(taskId) {
+			if (works.has(taskId)) return null;
+			const left = leftSuspended.get(taskId);
+			return left ? `the node daemon restarted while ${left.suspended.agent} waited for your reply, and doesn't keep a waiting Session across a restart` : "it isn't keeping that Task's Session";
+		},
 		stop: stopAll,
 		async leave() {
 			leaving = true;
@@ -9200,6 +11207,10 @@ async function startNode(options) {
 		message: `Discarded a message in the outbox that this daemon can't read (${kind === null ? file : `${file}, a ${kind}`}): the Platform never hears it.`
 	});
 	const inbox = await openInbox(join(options.stateDir, "inbox"));
+	const handed = await openHandedImages({
+		dir: join(options.stateDir, "handed-images"),
+		accepts: (to) => to.of === "reply" ? runner.whyNoReply(to.taskId) : chats.whyNoImages(to.chatId, to.turn)
+	});
 	const underWay = await openTasksUnderWay(join(options.stateDir, "under-way"), (message) => onEvent({
 		type: "problem",
 		message
@@ -9222,6 +11233,7 @@ async function startNode(options) {
 		credential,
 		os: options.os ?? await describeMachine(),
 		outbox,
+		uploadImages: platformImageUploads(credential),
 		inbox,
 		onMessage: (message) => {
 			switch (message.kind) {
@@ -9296,7 +11308,8 @@ async function startNode(options) {
 		signal: stopRequests.signal,
 		machine: options.machine,
 		workspacesDir,
-		millwrightDir: millwrightAtWorkFolder(options.stateDir)
+		millwrightDir: millwrightAtWorkFolder(options.stateDir),
+		handed
 	});
 	const skills = createSkillCopies({
 		stateDir: options.stateDir,
@@ -9310,7 +11323,10 @@ async function startNode(options) {
 		...options.clock === void 0 ? {} : { clock: options.clock },
 		intervalMs: options.sweepIntervalMs ?? 864e5,
 		onSwept: (workspace) => chats.swept(workspace),
-		sweepAlso: (before) => skills.sweep(before),
+		sweepAlso: async (before) => {
+			await skills.sweep(before);
+			await handed.sweep(before);
+		},
 		onEvent
 	});
 	const runner = createTaskRunner({
@@ -9326,7 +11342,8 @@ async function startNode(options) {
 		underWay,
 		workspaces: sweep,
 		skills,
-		checkoutTimeoutMs: options.checkoutTimeoutMs ?? 6e5
+		checkoutTimeoutMs: options.checkoutTimeoutMs ?? 6e5,
+		handed
 	});
 	const chats = createChatRunner({
 		connector,
@@ -9339,6 +11356,7 @@ async function startNode(options) {
 		workspaces: sweep,
 		skills,
 		checkoutTimeoutMs: options.checkoutTimeoutMs ?? 6e5,
+		handed,
 		onEvent
 	});
 	await runner.reportLeftUnderWay();
@@ -9749,7 +11767,7 @@ async function runCli(args, io, context = {}) {
 	const stateDir = defaultStateDir(context.env);
 	if (values.version && positionals.length === 0) {
 		const version = installed.from === "npm" ? ` ${installed.version}` : "";
-		io.log(`${PROGRAM}${version} (protocol 24)`);
+		io.log(`${PROGRAM}${version} (protocol 25)`);
 		return 0;
 	}
 	if (verb === "join" && rest.length === 2) {
@@ -9850,7 +11868,8 @@ async function startCommand(io, started, context) {
 		...context.protocolRetryMs === void 0 ? {} : { protocolRetryMs: context.protocolRetryMs }
 	});
 	node.resolve(running);
-	context.signal?.addEventListener("abort", () => void stop(), { once: true });
+	if (context.signal?.aborted) stop();
+	else context.signal?.addEventListener("abort", () => void stop(), { once: true });
 	await running.stopped;
 	await stopping;
 	if (successor && !context.signal?.aborted) return successor.npm.run(successor.version, started.args, {
@@ -9862,12 +11881,12 @@ async function startCommand(io, started, context) {
 /** What the CLI prints of a move the daemon makes once the Platform refused its protocol. */
 function describeMove(move) {
 	if (move.kind === "unreadable") return {
-		text: `The Platform refused this daemon's protocol (24) without saying which it speaks: ${move.reason}`,
+		text: `The Platform refused this daemon's protocol (25) without saying which it speaks: ${move.reason}`,
 		problem: true
 	};
 	const { platformVersion } = move;
-	if (move.kind === "wait-for-platform") return { text: `The Platform speaks protocol ${platformVersion}, older than this daemon's 24. Waiting for the Platform to be updated; trying again every few minutes.` };
-	const newer = `The Platform speaks protocol ${platformVersion}, newer than this daemon's 24`;
+	if (move.kind === "wait-for-platform") return { text: `The Platform speaks protocol ${platformVersion}, older than this daemon's 25. Waiting for the Platform to be updated; trying again every few minutes.` };
+	const newer = `The Platform speaks protocol ${platformVersion}, newer than this daemon's 25`;
 	if (move.kind === "update-checkout") return {
 		text: `${newer}: update the checkout, then start the Node again.`,
 		problem: true