@aistrike-dev/ui-shell-dev 2.0.3 → 2.1.1

package/platform/assistant/mock.js

@@ -1,33 +1,351 @@
 import { createHash, randomUUID } from "node:crypto";
-//#region src/mock/conversations.ts
-/** `cnv_` and a UUID's 32 hex digits (agent conversations API 3, ids). */
-var newConversationId = () => `cnv_${randomUUID().replace(/-/g, "")}`;
-/** The mock's conversations, by id, in memory: at most `limit` (default 100). */
-function createConversations(limit = 100, newId = newConversationId) {
-	const byId = /* @__PURE__ */ new Map();
+//#region src/mock/http.ts
+/** The sessions API's media type (session pane design 9); `application/json` alone gets the latest version. */
+var MEDIA_TYPE = "application/vnd.aistrike.sessions+json; version=1.0";
+/** The body's bytes, or `'too_large'` once they pass `cap`; the rest is read and dropped so the client can finish sending. */
+async function readRaw(req, cap) {
+	const declared = Number(req.headers["content-length"]);
+	let over = Number.isFinite(declared) && declared > cap;
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of req) {
+		if (over) continue;
+		const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+		size += buffer.length;
+		if (size > cap) {
+			over = true;
+			chunks.length = 0;
+		} else chunks.push(buffer);
+	}
+	return over ? "too_large" : Buffer.concat(chunks);
+}
+/** A JSON body; `undefined` when it does not parse. */
+async function readJson(req, cap = 1048576) {
+	const raw = await readRaw(req, cap);
+	if (raw === "too_large") return;
+	try {
+		return JSON.parse(raw.toString("utf8"));
+	} catch {
+		return;
+	}
+}
+/** The client may read these on a cross-origin response: the dev servers answer CORS but expose nothing by default. */
+var EXPOSED = "ETag, Location, Content-Disposition";
+function sendJson(res, status, body, contentType = "application/json") {
+	res.statusCode = status;
+	res.setHeader("Content-Type", contentType);
+	res.setHeader("Access-Control-Expose-Headers", EXPOSED);
+	res.end(JSON.stringify(body));
+}
+/** An error in the API's envelope: `errors: [{ id, message, referenceId }]` and no `data`. */
+function refuse(res, status, id, message) {
+	sendJson(res, status, { errors: [{
+		id,
+		message,
+		referenceId: randomUUID()
+	}] });
+}
+/** The vendor type when the request asked for it, else plain JSON. */
+function contentTypeFor(req) {
+	return /application\/vnd\.aistrike\.sessions\+json/i.test(req.headers.accept ?? "") ? MEDIA_TYPE : "application/json";
+}
+/** A JSON answer with an `ETag` over its bytes; `304` when the client already holds it. */
+function sendTagged(req, res, status, body) {
+	const text = JSON.stringify(body);
+	const etag = `"${createHash("sha256").update(text).digest("hex").slice(0, 32)}"`;
+	res.setHeader("ETag", etag);
+	res.setHeader("Access-Control-Expose-Headers", EXPOSED);
+	if (status === 200 && req.headers["if-none-match"] === etag) {
+		res.statusCode = 304;
+		res.end();
+		return;
+	}
+	res.statusCode = status;
+	res.setHeader("Content-Type", contentTypeFor(req));
+	res.end(text);
+}
+/** Bytes as a download: their type, `content-disposition: attachment`, and no sniffing. */
+function sendBytes(res, bytes, type, disposition) {
+	res.statusCode = 200;
+	res.setHeader("Content-Type", type);
+	res.setHeader("Content-Length", String(bytes.length));
+	res.setHeader("Content-Disposition", disposition);
+	res.setHeader("X-Content-Type-Options", "nosniff");
+	res.setHeader("Access-Control-Expose-Headers", EXPOSED);
+	res.end(bytes);
+}
+var pause = async (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+//#endregion
+//#region src/mock/access.ts
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var MODES = /* @__PURE__ */ new Set([
+	"auto",
+	"ask",
+	"plan",
+	"agent"
+]);
+var isSkillRef = (value) => value === void 0 || isObject(value) && typeof value.id === "string";
+var isIdList = (value) => value === void 0 || Array.isArray(value) && value.every((id) => typeof id === "string");
+function isInput(value) {
+	if (!isObject(value)) return false;
+	switch (value.kind) {
+		case "message": return typeof value.text === "string" && Array.isArray(value.refs) && isSkillRef(value.skill) && isIdList(value.attachments);
+		case "page_tool_results": return Array.isArray(value.results) && value.results.every((result) => isObject(result) && typeof result.id === "string");
+		case "approval": return typeof value.id === "string" && typeof value.approve === "boolean";
+		default: return false;
+	}
+}
+/** Enough of the context's shape for the responder to read it without throwing. */
+function isContext(value) {
+	if (!isObject(value)) return false;
+	const { route, title, screen, domains, pageTools, suggestions } = value;
+	const screenOk = screen === null || isObject(screen) && Array.isArray(screen.entities) && Array.isArray(screen.selection);
+	return isObject(route) && typeof title === "string" && screenOk && [
+		domains,
+		pageTools,
+		suggestions
+	].every((list) => Array.isArray(list));
+}
+/** `{ tenantIds: [...] }` with at least one id, or `{ all: true }`, and nothing else (authorization standard). */
+function isTenantScope(value) {
+	if (!isObject(value)) return false;
+	const keys = Object.keys(value);
+	if (keys.length === 1 && value.all === true) return true;
+	const ids = value.tenantIds;
+	return keys.length === 1 && Array.isArray(ids) && ids.length > 0 && ids.every((id) => typeof id === "string" && id !== "") && new Set(ids).size === ids.length;
+}
+var isScope = (value) => isObject(value) && typeof value.orgId === "string" && value.orgId !== "" && isTenantScope(value.tenantScope);
+var tenantsKey = (scope) => "all" in scope ? "*" : [...scope.tenantIds].sort().join("\n");
+/** The same org and the same tenants, in any order. */
+function sameScope(a, b) {
+	return a.orgId === b.orgId && tenantsKey(a.tenantScope) === tenantsKey(b.tenantScope);
+}
+var isRequest = (value) => isScope(value) && isObject(value) && MODES.has(value.mode) && isContext(value.context) && isInput(value.input);
+/**
+* The scope a request names in its query: `orgId` and one or more `tenantId`, or `orgId` and `all=true` (agent
+* conversations API 5.3, open question 2). `null` when it names none; `'invalid'` when it names one badly.
+*/
+function queryScope(url) {
+	const orgId = url.searchParams.get("orgId");
+	const tenants = url.searchParams.getAll("tenantId");
+	const all = url.searchParams.get("all");
+	if (orgId === null && tenants.length === 0 && all === null) return null;
+	const scope = {
+		orgId,
+		tenantScope: all === "true" ? { all: true } : { tenantIds: tenants }
+	};
+	return (all === null || all === "true" && tenants.length === 0) && isScope(scope) ? scope : "invalid";
+}
+var SCOPE_RULE = "The scope is orgId with tenantId, or orgId with all=true";
+/** Unknown, deleted, or in another scope: the same answer (agent conversations API 4). */
+var notFound = (res) => refuse(res, 404, "session_not_found", "No such session");
+/**
+* A session the request may see: it exists, and the scope the query names, if it names one, is its own. Otherwise the
+* answer is sent and the result is `null`.
+*/
+function lookup(url, id, res, sessions) {
+	const scope = queryScope(url);
+	if (scope === "invalid") {
+		refuse(res, 400, "invalid_request", SCOPE_RULE);
+		return null;
+	}
+	const session = sessions.get(id);
+	if (session === void 0 || scope !== null && !sameScope(session.scope, scope)) {
+		notFound(res);
+		return null;
+	}
+	return session;
+}
+//#endregion
+//#region src/mock/multipart.ts
+/** The boundary of a `multipart/form-data` content type, or `null` when it is not one or has none. */
+function boundaryOf(contentType) {
+	if (contentType === void 0 || !/^multipart\/form-data\s*(;|$)/i.test(contentType.trim())) return null;
+	const match = /;\s*boundary=(?:"([^"]+)"|([^;\s]+))/i.exec(contentType);
+	const boundary = match?.[1] ?? match?.[2] ?? null;
+	return boundary !== null && boundary.length >= 1 && boundary.length <= 70 ? boundary : null;
+}
+/** A header parameter, quoted or not; `filename*` (RFC 5987, `UTF-8''…`) wins over `filename`. */
+function parameter(header, name) {
+	const extended = new RegExp(`;\\s*${name}\\*\\s*=\\s*([^']*)'[^']*'([^;]*)`, "i").exec(header);
+	if (extended !== null && /^utf-8$/i.test(extended[1])) try {
+		return decodeURIComponent(extended[2].trim());
+	} catch {
+		return null;
+	}
+	const plain = new RegExp(`;\\s*${name}\\s*=\\s*(?:"((?:[^"\\\\]|\\\\.)*)"|([^;]*))`, "i").exec(header);
+	if (plain === null) return null;
+	return plain[1] === void 0 ? plain[2].trim() : plain[1].replace(/\\(.)/g, "$1");
+}
+function headersOf(block) {
+	const headers = {};
+	for (const line of block.split("\r\n")) {
+		const colon = line.indexOf(":");
+		if (colon > 0) headers[line.slice(0, colon).trim().toLowerCase()] = line.slice(colon + 1).trim();
+	}
+	return headers;
+}
+var CRLF = Buffer.of(13, 10);
+var HEADERS_END = Buffer.concat([CRLF, CRLF]);
+/** The part whose headers start at `at` (just past its delimiter's CRLF), and where it ends; `null` if malformed. */
+function partAt(body, at, next) {
+	const headersEnd = body.indexOf(HEADERS_END, at);
+	if (headersEnd === -1) return null;
+	const headers = headersOf(body.subarray(at, headersEnd).toString("utf8"));
+	const dataStart = headersEnd + HEADERS_END.length;
+	const dataEnd = body.indexOf(next, dataStart);
+	const disposition = headers["content-disposition"] ?? "";
+	const name = /^form-data\b/i.test(disposition) ? parameter(disposition, "name") : null;
+	if (dataEnd === -1 || name === null) return null;
 	return {
-		get: (id) => byId.get(id),
-		create(scope) {
-			const now = (/* @__PURE__ */ new Date()).toISOString();
-			const conversation = {
-				id: newId(),
-				scope,
-				createdAt: now,
-				updatedAt: now,
-				busy: false,
-				user: null,
-				context: null,
-				pending: null
-			};
-			byId.set(conversation.id, conversation);
-			while (byId.size > limit) {
-				const oldest = byId.keys().next().value;
-				if (oldest === void 0) break;
-				byId.delete(oldest);
-			}
-			return conversation;
-		}
+		part: {
+			name,
+			filename: parameter(disposition, "filename"),
+			contentType: headers["content-type"] ?? null,
+			data: body.subarray(dataStart, dataEnd)
+		},
+		end: dataEnd + next.length
+	};
+}
+/** Where the first part starts: past the first delimiter, which starts the body or follows a preamble's CRLF; -1 if none. */
+function firstPart(body, delimiter, next) {
+	if (body.subarray(0, delimiter.length).equals(delimiter)) return delimiter.length;
+	const found = body.indexOf(next);
+	return found === -1 ? -1 : found + next.length;
+}
+/** The parts of a body, or `null` when it is not well-formed multipart with this boundary. */
+function parseMultipart(body, boundary) {
+	const delimiter = Buffer.from(`--${boundary}`);
+	const next = Buffer.concat([CRLF, delimiter]);
+	let at = firstPart(body, delimiter, next);
+	const parts = [];
+	while (at !== -1) {
+		if (body.subarray(at, at + 2).toString("latin1") === "--") return parts;
+		while (body[at] === 32 || body[at] === 9) at += 1;
+		const found = body.subarray(at, at + 2).equals(CRLF) ? partAt(body, at + 2, next) : null;
+		if (found === null) return null;
+		parts.push(found.part);
+		at = found.end;
+	}
+	return null;
+}
+/**
+* A file name fit to show and to put in a header: its last path segment, without control characters, at most 255
+* characters; `file` when nothing is left. It is shown as text and never interpreted.
+*/
+function safeFileName(raw) {
+	const cleaned = ((raw ?? "").split(/[\\/]/).at(-1) ?? "").replace(/[\u0000-\u001f\u007f]/g, "").trim().slice(0, 255);
+	return cleaned === "" || cleaned === "." || cleaned === ".." ? "file" : cleaned;
+}
+/** `content-disposition: attachment` for a name: an ASCII fallback and the exact name in `filename*` (RFC 6266). */
+function attachmentDisposition(name) {
+	return `attachment; filename="${name.replace(/[^\x20-\x7e]/g, "_").replace(/["\\]/g, "_")}"; filename*=UTF-8''${encodeURIComponent(name)}`;
+}
+//#endregion
+//#region src/mock/files.ts
+/** Limits (session pane design 9.4, 14). */
+var MAX_FILE = 20971520;
+var MAX_ATTACHMENTS = 100;
+/** Refused to exercise the UI's `415`. */
+var REFUSED_TYPES = /* @__PURE__ */ new Set(["application/x-msdownload"]);
+var ONE_FILE = "The body is multipart/form-data with one file part";
+var TOO_LARGE = "A file is at most 20 MiB";
+/** The one `file` part of an upload, `'too_large'`, or `null` when the body is not one file part. */
+async function fileOf(req, boundary) {
+	const raw = await readRaw(req, 21037056);
+	if (raw === "too_large") return raw;
+	const files = parseMultipart(raw, boundary)?.filter((part) => part.name === "file") ?? [];
+	if (files.length !== 1) return null;
+	return files[0].data.length > MAX_FILE ? "too_large" : files[0];
+}
+/** The part's type, as `type/subtype`; `application/octet-stream` when it has none or a malformed one. */
+function mimeOf(part) {
+	const declared = (part.contentType ?? "").split(";")[0].trim().toLowerCase();
+	return /^[a-z0-9][\w.+-]*\/[\w.+-]+$/.test(declared) ? declared : "application/octet-stream";
+}
+/** `POST /api/sessions/{id}/attachments`: one `file` part, kept in memory only (9.8). */
+async function upload(req, res, session) {
+	if (session.attachments.size >= MAX_ATTACHMENTS) {
+		refuse(res, 409, "too_many_attachments", `A session holds at most ${MAX_ATTACHMENTS} attachments`);
+		return;
+	}
+	const boundary = boundaryOf(req.headers["content-type"]);
+	const file = boundary === null ? null : await fileOf(req, boundary);
+	if (file === null || file === "too_large") {
+		refuse(res, file === null ? 400 : 413, file === null ? "invalid_request" : "request_too_large", file === null ? ONE_FILE : TOO_LARGE);
+		return;
+	}
+	const mime = mimeOf(file);
+	if (REFUSED_TYPES.has(mime)) {
+		refuse(res, 415, "unsupported_media_type", `${mime} is not accepted`);
+		return;
+	}
+	if (session.deleted) {
+		notFound(res);
+		return;
+	}
+	const id = `att_${randomUUID().replace(/-/g, "")}`;
+	const attachment = {
+		id,
+		name: safeFileName(file.filename),
+		mime,
+		size: file.data.length,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		url: `sessions/${session.id}/attachments/${id}`
 	};
+	session.attachments.set(id, {
+		attachment,
+		bytes: Buffer.from(file.data),
+		usedBy: null
+	});
+	res.setHeader("Location", `/api/${attachment.url}`);
+	sendJson(res, 201, { data: attachment }, contentTypeFor(req));
+}
+/** `GET` (the bytes, as a download) and `DELETE` (until a turn sends it) of one attachment. */
+function attachmentRoute(req, res, session, attachmentId) {
+	const stored = session.attachments.get(attachmentId);
+	if (stored === void 0) {
+		refuse(res, 404, "not_found", "No such attachment");
+		return;
+	}
+	if (req.method === "GET") {
+		sendBytes(res, stored.bytes, stored.attachment.mime, attachmentDisposition(stored.attachment.name));
+		return;
+	}
+	if (stored.usedBy !== null) {
+		refuse(res, 409, "attachment_in_use", "A turn has sent this attachment");
+		return;
+	}
+	session.attachments.delete(attachmentId);
+	sendJson(res, 200, { data: { id: attachmentId } }, contentTypeFor(req));
+}
+/** One CSV cell (RFC 4180); text a spreadsheet would read as a formula is prefixed with `'`. */
+function cell(value) {
+	if (value === null || value === void 0) return "";
+	let text = typeof value === "string" ? value : JSON.stringify(value);
+	if (typeof value === "string" && /^[=+\-@\t\r]/.test(text)) text = `'${text}`;
+	return /[",\r\n]/.test(text) ? `"${text.replace(/"/g, "\"\"")}"` : text;
+}
+/** `GET /api/sessions/{id}/artifacts/{artifactId}` (9.5): a table as CSV, an image's or a file's bytes. */
+function artifactRoute(res, session, artifactId) {
+	const found = session.artifacts.find((candidate) => candidate.id === artifactId);
+	if (found === void 0) {
+		refuse(res, 404, "not_found", "No such artifact");
+		return;
+	}
+	if (found.kind === "table") {
+		const lines = [found.columns.map((column) => cell(column.label)).join(",")].concat(found.rows.map((row) => found.columns.map((column) => cell(row[column.id])).join(",")));
+		sendBytes(res, Buffer.from(`${lines.join("\r\n")}\r\n`), "text/csv; charset=utf-8", attachmentDisposition(`${safeFileName(found.title)}.csv`));
+		return;
+	}
+	const bytes = session.artifactBytes.get(artifactId);
+	if ((found.kind === "image" || found.kind === "file") && bytes !== void 0) {
+		sendBytes(res, bytes, found.mime, attachmentDisposition(safeFileName(found.title)));
+		return;
+	}
+	refuse(res, 400, "invalid_request", "Only table, image and file artifacts have content to fetch");
 }
 //#endregion
 //#region ../../packages/sdk/dist/assistant/refs.js
@@ -201,7 +519,46 @@ var SEED_PROMPTS = [{
 		tool: "search_alerts",
 		input: { query: "credential dumping" }
 	}]
+}, {
+	domainId: "lab",
+	id: "alerts-by-host",
+	text: "Alerts by host",
+	label: "Alerts by host",
+	expects: []
 }];
+/** Alert counts per host over a day, for the chart and the table the mock answers "Alerts by host" with. Synthetic. */
+var HOSTS = [
+	{
+		host: "web-01",
+		alerts: 42,
+		critical: 3
+	},
+	{
+		host: "db-02",
+		alerts: 27,
+		critical: 1
+	},
+	{
+		host: "build-07",
+		alerts: 19,
+		critical: 0
+	},
+	{
+		host: "vpn-gw-1",
+		alerts: 14,
+		critical: 2
+	},
+	{
+		host: "mail-03",
+		alerts: 9,
+		critical: 0
+	},
+	{
+		host: "hr-laptop-12",
+		alerts: 5,
+		critical: 1
+	}
+];
 var SEED_SKILLS = [{
 	id: "triage-alert",
 	title: "Triage an alert",
@@ -400,7 +757,7 @@ var CHANGE = /\b(suppress|select|highlight|close|assign|delete|disable)\b/i;
 * Runs the calls: its own at once, reported as steps, then what they found; the page's asked of the UI, whose results
 * close the turn.
 */
-function run(calls, refs, conversation) {
+function run(calls, refs, session) {
 	const out = [];
 	const lines = [];
 	const asked = [];
@@ -436,12 +793,13 @@ function run(calls, refs, conversation) {
 		type: "done",
 		stop: "end"
 	}];
-	conversation.pending = {
+	session.pending = {
 		kind: "page_tool",
 		calls: calls.filter((c) => c.tool.kind === "page").map((c) => {
 			return {
 				id: c.id,
-				tool: qualified(c.tool)
+				tool: qualified(c.tool),
+				input: c.input
 			};
 		})
 	};
@@ -451,7 +809,7 @@ function run(calls, refs, conversation) {
 	}];
 }
 /** Holds the calls for the person's approval: each as a step that waits, then the approval itself. */
-function propose(calls, conversation) {
+function propose(calls, session) {
 	const id = nextId();
 	const steps = calls.map((c) => {
 		return {
@@ -462,7 +820,7 @@ function propose(calls, conversation) {
 			state: "awaiting-approval"
 		};
 	});
-	conversation.pending = {
+	session.pending = {
 		kind: "approval",
 		id,
 		calls: calls.map((c) => {
@@ -499,13 +857,13 @@ function rules(user, context, tools) {
 * The mode's say on what the rules decided (plan decision 2): Ask refuses a change in text, Plan holds a write for
 * approval, Agent runs it, and Auto runs one change and plans more than one.
 */
-function actOn(decided, mode, user, conversation) {
+function actOn(decided, mode, user, session) {
 	if ("text" in decided) return [modeEvent(mode, actingFor(mode, decided.acting, 0), decided.reason), ...say(decided.text)];
 	const changes = decided.calls.filter((c) => c.tool.effect !== "read").length;
 	const acts = actingFor(mode, decided.acting, changes);
 	const head = modeEvent(mode, acts, acts === decided.acting ? decided.reason : "more than one change, so a plan first");
-	if (changes === 0 || acts === "agent") return [head, ...run(decided.calls, user.refs, conversation)];
-	return acts === "plan" ? [head, ...propose(decided.calls, conversation)] : [head, ...say(ASK_REFUSAL)];
+	if (changes === 0 || acts === "agent") return [head, ...run(decided.calls, user.refs, session)];
+	return acts === "plan" ? [head, ...propose(decided.calls, session)] : [head, ...say(ASK_REFUSAL)];
 }
 /** A skill chosen by id: the scripted reply names it and echoes the argument, or names it alone for empty text. */
 function useSkill(skill, user, mode) {
@@ -514,27 +872,161 @@ function useSkill(skill, user, mode) {
 	const reply = argument === "" ? `${title}. Nothing more was given, so I used the page as it is.` : `${title}: ${argument}…`;
 	return [modeEvent(mode, actingFor(mode, "ask", 0), QUESTION), ...say(`${reply} This is the mock's scripted reply; it runs no skill.`)];
 }
+/** The chart and the table of alerts by host, as the mock's answer and its seeded session both hold them. */
+function hostChart(id) {
+	return {
+		id,
+		kind: "chart",
+		title: "Alerts by host",
+		config: {
+			title: "Alerts by host",
+			subtitle: "Last 24 hours",
+			chartType: "bar",
+			legend: {
+				show: true,
+				position: "bottom"
+			},
+			xAxes: [{
+				id: "host",
+				type: "category",
+				name: "Host"
+			}],
+			yAxes: [{
+				id: "alerts",
+				type: "value",
+				name: "Alerts",
+				min: 0
+			}],
+			series: [{
+				id: "alerts",
+				name: "Alerts",
+				fields: {
+					x: "host",
+					y: "alerts"
+				}
+			}, {
+				id: "critical",
+				name: "Critical",
+				fields: {
+					x: "host",
+					y: "critical"
+				}
+			}]
+		},
+		rows: HOSTS.map((row) => {
+			return { ...row };
+		})
+	};
+}
+function hostTable(sessionId, id) {
+	return {
+		id,
+		kind: "table",
+		title: "Alerts by host",
+		columns: [
+			{
+				id: "host",
+				label: "Host"
+			},
+			{
+				id: "alerts",
+				label: "Alerts"
+			},
+			{
+				id: "critical",
+				label: "Critical"
+			}
+		],
+		rows: HOSTS.map((row) => {
+			return { ...row };
+		}),
+		downloadUrl: `sessions/${sessionId}/artifacts/${id}`
+	};
+}
+var ALERTS_BY_HOST = /\balerts by host\b/i;
+var CRITICAL_ALERTS = /\bshow critical alerts\b/i;
+var MY_APPEARANCE = /\bmy appearance\b/i;
+/** "Alerts by host": a chart and a table of the same counts (session pane design 10). */
+function chartingHosts(mode, session) {
+	const [top] = [...HOSTS].sort((a, b) => b.alerts - a.alerts);
+	return [
+		modeEvent(mode, actingFor(mode, "ask", 0), QUESTION),
+		...speak(`${top.host} raised the most alerts in the last 24 hours (${top.alerts}). The chart and the table hold the same counts.`),
+		{
+			type: "artifact",
+			...hostChart(nextId())
+		},
+		{
+			type: "artifact",
+			...hostTable(session.id, nextId())
+		},
+		{
+			type: "done",
+			stop: "end"
+		}
+	];
+}
+/** "Show critical alerts": a view the person can open in the UI. */
+function showingCritical(mode) {
+	return [
+		modeEvent(mode, actingFor(mode, "ask", 0), QUESTION),
+		...speak("3 alerts are critical. Open them in Alerts to triage them."),
+		{
+			type: "view",
+			id: nextId(),
+			route: "/lab/alerts?severity=critical",
+			label: "Open Alerts filtered to critical",
+			reason: "The critical alerts you asked for"
+		},
+		{
+			type: "done",
+			stop: "end"
+		}
+	];
+}
+/** "Open my appearance": a view of a page every dev host serves, so View in UI can succeed there. */
+function showingAppearance(mode) {
+	return [
+		modeEvent(mode, actingFor(mode, "ask", 0), QUESTION),
+		...speak("Your appearance settings hold your theme and interaction mode. Open them to review."),
+		{
+			type: "view",
+			id: nextId(),
+			route: "/settings/appearance",
+			label: "Open your appearance settings",
+			reason: "The page you asked for"
+		},
+		{
+			type: "done",
+			stop: "end"
+		}
+	];
+}
 /** The first answer to a message: the rules, in order, then the mode's say on what they decided. */
-function answer(request, user, conversation) {
+function answer(request, user, session) {
 	const { mode, context } = request;
 	if (user.skill !== void 0) return useSkill(user.skill, user, mode);
+	const asked = stripMarkup(user.text);
+	if (ALERTS_BY_HOST.test(asked)) return chartingHosts(mode, session);
+	if (CRITICAL_ALERTS.test(asked)) return showingCritical(mode);
+	if (MY_APPEARANCE.test(asked)) return showingAppearance(mode);
 	const tools = toolsOf(context);
 	const suggested = following(user, context, tools);
 	if (suggested === null && mode === "ask" && CHANGE.test(user.text)) return [modeEvent(mode, "ask", QUESTION), ...say(ASK_REFUSAL)];
-	return actOn(suggested ?? rules(user, context, tools), mode, user, conversation);
+	return actOn(suggested ?? rules(user, context, tools), mode, user, session);
 }
-function afterPageTools(results, conversation) {
-	const pending = conversation.pending;
+function afterPageTools(results, session) {
+	const pending = session.pending;
 	if (pending?.kind !== "page_tool") return {
 		status: 409,
-		message: "No page tool is waiting in this conversation"
+		message: "No page tool is waiting in this session"
 	};
-	conversation.pending = null;
+	session.pending = null;
 	const tools = new Map(pending.calls.map((c) => [c.id, c.tool]));
 	return say(results.map((r) => sentence(tools.get(r.id) ?? "tool", r.ok, r.result, r.error)).join("\n\n"));
 }
 /** Runs the approved calls with the tools offered now; one the page no longer offers fails as the shell would say. */
-function approved(planned, context, conversation) {
+function approved(planned, context, session) {
 	const tools = toolsOf(context);
 	const calls = [];
 	const missing = [];
@@ -555,17 +1047,17 @@ function approved(planned, context, conversation) {
 			input: input ?? {}
 		});
 	}
-	return [...missing, ...run(calls, conversation.user?.refs ?? [], conversation)];
+	return [...missing, ...run(calls, session.user?.refs ?? [], session)];
 }
-function afterApproval(request, input, conversation) {
-	const pending = conversation.pending;
+function afterApproval(request, input, session) {
+	const pending = session.pending;
 	if (pending?.kind !== "approval" || pending.id !== input.id) return {
 		status: 409,
-		message: `No approval ${input.id} is waiting in this conversation`
+		message: `No approval ${input.id} is waiting in this session`
 	};
-	conversation.pending = null;
-	conversation.context = request.context;
-	if (input.approve) return approved(pending.calls, request.context, conversation);
+	session.pending = null;
+	session.context = request.context;
+	if (input.approve) return approved(pending.calls, request.context, session);
 	return [...pending.calls.map((c) => {
 		return {
 			type: "step",
@@ -577,18 +1069,84 @@ function afterApproval(request, input, conversation) {
 	}), ...say("Understood, I left it alone.")];
 }
 /**
+* What the harness used for a turn: one of each kind, each running and then done, so the column fills in a demo. Memory
+* and a connector it pulled data through are sources; an agent and a workflow are actions.
+*/
+var RESOURCES = [
+	{
+		kind: "memory",
+		use: "source",
+		label: "Triage preferences",
+		detail: "Read 3 notes"
+	},
+	{
+		kind: "connector",
+		use: "source",
+		label: "Lab API",
+		detail: "Searched alerts"
+	},
+	{
+		kind: "agent",
+		use: "action",
+		label: "Alert triage",
+		detail: "Ranked the alerts in view"
+	},
+	{
+		kind: "workflow",
+		use: "action",
+		label: "Suppress duplicates",
+		detail: "Dry run: nothing changed"
+	}
+];
+function resources() {
+	return RESOURCES.flatMap((resource) => {
+		const id = nextId();
+		return [{
+			type: "resource",
+			id,
+			...resource,
+			state: "running"
+		}, {
+			type: "resource",
+			id,
+			...resource,
+			state: "done"
+		}];
+	});
+}
+/** A size as a person reads it: bytes, KB or MB, at 1024. */
+function sizeOf(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	return bytes < 1048576 ? `${(bytes / 1024).toFixed(1)} KB` : `${(bytes / 1048576).toFixed(1)} MB`;
+}
+/** A message's attachments, named with their sizes, ahead of the rest of the answer. */
+function attached(input, session) {
+	const files = (input.attachments ?? []).flatMap((id) => {
+		const stored = session.attachments.get(id);
+		return stored === void 0 ? [] : [`${stored.attachment.name} (${sizeOf(stored.attachment.size)})`];
+	});
+	if (files.length === 0) return [];
+	return speak(`You attached ${files.length} ${files.length === 1 ? "file" : "files"}: ${files.join(", ")}.\n\n`);
+}
+/**
 * One request of a turn: a message starts the turn afresh, discarding anything it waited on; page tool results and an
-* approval answer what the conversation waits on, and anything else is a 409.
+* approval answer what the session waits on, and anything else is a 409.
 */
-function respond(request, conversation) {
+function respond(request, session) {
 	const { input } = request;
 	if (input.kind === "message") {
-		conversation.user = input;
-		conversation.context = request.context;
-		conversation.pending = null;
-		return answer(request, input, conversation);
+		session.user = input;
+		session.context = request.context;
+		session.pending = null;
+		const [head, ...rest] = answer(request, input, session);
+		return [
+			head,
+			...resources(),
+			...attached(input, session),
+			...rest
+		];
 	}
-	return input.kind === "page_tool_results" ? afterPageTools(input.results, conversation) : afterApproval(request, input, conversation);
+	return input.kind === "page_tool_results" ? afterPageTools(input.results, session) : afterApproval(request, input, session);
 }
 /**
 * `GET /api/prompts`: a domain's seeded prompts, without what they expect, which stays on the backend. In Ask, a
@@ -604,87 +1162,135 @@ function promptsFor(domainId, mode, prompts = SEED_PROMPTS) {
 		};
 	});
 }
-//#endregion
-//#region src/mock/chatHandler.ts
-async function readBody(req) {
-	const chunks = [];
-	for await (const chunk of req) chunks.push(chunk);
-	try {
-		return JSON.parse(Buffer.concat(chunks).toString("utf8"));
-	} catch {
-		return;
-	}
+var createChannel = (retain = 500, lastEventId = 0) => {
+	return {
+		lastEventId,
+		retained: [],
+		subscribers: /* @__PURE__ */ new Set(),
+		retain
+	};
+};
+/** Publishes one event: the next id, kept in the ring, sent to every subscriber. */
+function publish(channel, type, data) {
+	channel.lastEventId += 1;
+	const event = {
+		id: channel.lastEventId,
+		type,
+		data
+	};
+	channel.retained.push(event);
+	if (channel.retained.length > channel.retain) channel.retained.splice(0, channel.retained.length - channel.retain);
+	for (const subscriber of [...channel.subscribers]) subscriber.send(event);
+	return event;
 }
-var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var MODES = /* @__PURE__ */ new Set([
-	"auto",
-	"ask",
-	"plan",
-	"agent"
-]);
-var isSkillRef = (value) => value === void 0 || isObject(value) && typeof value.id === "string";
-function isInput(value) {
-	if (!isObject(value)) return false;
-	switch (value.kind) {
-		case "message": return typeof value.text === "string" && Array.isArray(value.refs) && isSkillRef(value.skill);
-		case "page_tool_results": return Array.isArray(value.results) && value.results.every((result) => isObject(result) && typeof result.id === "string");
-		case "approval": return typeof value.id === "string" && typeof value.approve === "boolean";
-		default: return false;
-	}
+/**
+* The retained events after `after`, or `'expired'` when some of them are no longer held: `after` is older than the
+* ring reaches back, or newer than anything published (a mock restarted since the client last read it).
+*/
+function replay(channel, after) {
+	if (after > channel.lastEventId) return "expired";
+	if (after === channel.lastEventId) return [];
+	const oldest = channel.retained[0]?.id;
+	if (oldest === void 0 || after < oldest - 1) return "expired";
+	return channel.retained.filter((event) => event.id > after);
 }
-/** Enough of the context's shape for the responder to read it without throwing. */
-function isContext(value) {
-	if (!isObject(value)) return false;
-	const { route, title, screen, domains, pageTools, suggestions } = value;
-	const screenOk = screen === null || isObject(screen) && Array.isArray(screen.entities) && Array.isArray(screen.selection);
-	return isObject(route) && typeof title === "string" && screenOk && [
-		domains,
-		pageTools,
-		suggestions
-	].every((list) => Array.isArray(list));
+function subscribe(channel, subscriber) {
+	channel.subscribers.add(subscriber);
+	return () => {
+		channel.subscribers.delete(subscriber);
+	};
 }
-/** `{ tenantIds: [...] }` with at least one id, or `{ all: true }`, and nothing else (authorization standard). */
-function isTenantScope(value) {
-	if (!isObject(value)) return false;
-	const keys = Object.keys(value);
-	if (keys.length === 1 && value.all === true) return true;
-	const ids = value.tenantIds;
-	return keys.length === 1 && Array.isArray(ids) && ids.length > 0 && ids.every((id) => typeof id === "string" && id !== "") && new Set(ids).size === ids.length;
+/** Publishes a last event, then ends every stream: the session was deleted or left the store. */
+function close(channel, type, data) {
+	publish(channel, type, data);
+	for (const subscriber of [...channel.subscribers]) subscriber.end();
+	channel.subscribers.clear();
 }
-var isScope = (value) => isObject(value) && typeof value.orgId === "string" && value.orgId !== "" && isTenantScope(value.tenantScope);
-/** The same org and the same tenants, in any order. */
-function sameScope(a, b) {
-	const tenants = (scope) => "all" in scope ? "*" : [...scope.tenantIds].sort().join("\n");
-	return a.orgId === b.orgId && tenants(a.tenantScope) === tenants(b.tenantScope);
+/** One event as `text/event-stream` text; with no id, no `id:` line. */
+function frame(type, data, id) {
+	return `${id === void 0 ? "" : `id: ${id}\n`}event: ${type}\ndata: ${JSON.stringify(data)}\n\n`;
 }
-var isRequest = (value) => isScope(value) && isObject(value) && MODES.has(value.mode) && isContext(value.context) && isInput(value.input);
-var pause = async (ms) => new Promise((resolve) => {
-	setTimeout(resolve, ms);
-});
-function sendJson(res, status, body) {
-	res.statusCode = status;
-	res.setHeader("Content-Type", "application/json");
-	res.end(JSON.stringify(body));
+//#endregion
+//#region src/mock/sessions.ts
+/** `ses_` and a UUID's 32 hex digits (the API's ids). */
+var newSessionId = () => `ses_${randomUUID().replace(/-/g, "")}`;
+var DELETED_REMEMBERED = 1e3;
+/** The mock's sessions, by id, in memory: at most `limit` (default 100). */
+function createSessions(limit = 100, newId = newSessionId) {
+	const byId = /* @__PURE__ */ new Map();
+	const deleted = /* @__PURE__ */ new Set();
+	const forget = (session) => {
+		session.deleted = true;
+		session.busy = false;
+		byId.delete(session.id);
+		deleted.add(session.id);
+		if (deleted.size > DELETED_REMEMBERED) {
+			const first = deleted.values().next().value;
+			if (first !== void 0) deleted.delete(first);
+		}
+		close(session.channel, "session.deleted", { id: session.id });
+	};
+	const evict = () => {
+		while (byId.size > limit) {
+			const oldest = [...byId.values()].filter((session) => !session.busy).reduce((found, session) => found === void 0 || session.updatedAt < found.updatedAt ? session : found, void 0);
+			if (oldest === void 0) break;
+			forget(oldest);
+		}
+	};
+	return {
+		get: (id) => byId.get(id),
+		wasDeleted: (id) => deleted.has(id),
+		all: () => [...byId.values()],
+		create(scope, at = {}) {
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const createdAt = at.createdAt ?? now;
+			const session = {
+				id: at.id ?? newId(),
+				scope,
+				title: null,
+				createdAt,
+				updatedAt: at.updatedAt ?? createdAt,
+				archivedAt: null,
+				busy: false,
+				deleted: false,
+				messages: [],
+				artifacts: [],
+				resources: [],
+				views: [],
+				attachments: /* @__PURE__ */ new Map(),
+				artifactBytes: /* @__PURE__ */ new Map(),
+				channel: createChannel(),
+				turn: null,
+				user: null,
+				context: null,
+				pending: null
+			};
+			byId.set(session.id, session);
+			evict();
+			return session;
+		},
+		remove(id) {
+			const session = byId.get(id);
+			if (session !== void 0) forget(session);
+			return session;
+		}
+	};
 }
-/** An error in the API's envelope (agent conversations API 8). */
-function refuse(res, status, id, message) {
-	sendJson(res, status, { errors: [{
-		id,
-		message,
-		referenceId: randomUUID()
-	}] });
+/** Marks a change: `updatedAt` moves to now, and always forward, so a precondition read before it never matches after. */
+function touch(session) {
+	const next = Math.max(Date.now(), Date.parse(session.updatedAt) + 1);
+	session.updatedAt = new Date(next).toISOString();
+	return session.updatedAt;
 }
-var notFound = (res) => refuse(res, 404, "conversation_not_found", "No such conversation");
-/** A conversation as the API returns it (agent conversations API 5.1). */
-function resourceOf(conversation) {
-	const { pending } = conversation;
-	let waiting = null;
-	if (pending?.kind === "approval") waiting = {
+/** What the session waits on from the UI, as the API states it. */
+function waitingOf(session) {
+	const { pending } = session;
+	if (pending?.kind === "approval") return {
 		kind: "approval",
 		id: pending.id,
 		steps: pending.calls.map((call) => call.id)
 	};
-	else if (pending?.kind === "page_tool") waiting = {
+	if (pending?.kind === "page_tool") return {
 		kind: "page_tool",
 		calls: pending.calls.map((call) => {
 			const [domainId, name] = call.tool.split("__");
@@ -692,89 +1298,681 @@ function resourceOf(conversation) {
 				id: call.id,
 				domainId,
 				name,
-				input: {}
+				input: call.input
 			};
 		})
 	};
+	return null;
+}
+function summaryOf(session) {
+	return {
+		id: session.id,
+		title: session.title,
+		createdAt: session.createdAt,
+		updatedAt: session.updatedAt,
+		archivedAt: session.archivedAt,
+		orgId: session.scope.orgId,
+		tenantScope: session.scope.tenantScope,
+		lastEventId: session.channel.lastEventId
+	};
+}
+var resourceOf = (session) => {
 	return {
-		id: conversation.id,
-		title: null,
-		createdAt: conversation.createdAt,
-		updatedAt: conversation.updatedAt,
-		archivedAt: null,
-		...conversation.scope,
-		waiting
-	};
-}
-/** `POST /api/conversations`: a new conversation in the body's scope. */
-async function create(req, res, conversations) {
-	const body = await readBody(req);
+		...summaryOf(session),
+		waiting: waitingOf(session)
+	};
+};
+/** `GET sessions/{id}`: the session with its transcript and everything collected in it. */
+function transcriptOf(session) {
+	const truncated = session.messages.length > 500;
+	return {
+		...resourceOf(session),
+		messages: truncated ? session.messages.slice(-500) : session.messages,
+		artifacts: session.artifacts,
+		resources: session.resources,
+		views: session.views,
+		...truncated ? { truncated: true } : {}
+	};
+}
+//#endregion
+//#region src/mock/sessionRoutes.ts
+var LIST_LIMIT = {
+	default: 20,
+	max: 100
+};
+var MAX_IDS = 8;
+var SORTS = ["updatedAt:desc", "createdAt:desc"];
+var ARCHIVED = [
+	"false",
+	"true",
+	"any"
+];
+/** `POST /api/sessions`: a new session in the body's scope. */
+async function create(req, res, sessions) {
+	const body = await readJson(req);
 	if (!isScope(body)) {
 		refuse(res, 400, "invalid_request", "The body must be { orgId, tenantScope }");
 		return;
 	}
-	const conversation = conversations.create({
+	const session = sessions.create({
 		orgId: body.orgId,
 		tenantScope: body.tenantScope
 	});
-	res.setHeader("Location", `/api/conversations/${conversation.id}`);
-	sendJson(res, 201, { data: resourceOf(conversation) });
+	res.setHeader("Location", `/api/sessions/${session.id}`);
+	sendTagged(req, res, 201, { data: resourceOf(session) });
+}
+/** A keyset cursor (REST standard): the sort and filters it was issued under, then the last item's sort key and id. */
+var cursorOf$1 = (query, key, id) => Buffer.from(JSON.stringify([
+	query.sort,
+	query.archived,
+	`${query.scope.orgId}|${tenantsKey(query.scope.tenantScope)}`,
+	key,
+	id
+])).toString("base64url");
+/** The keyset in a cursor this API issued for the same sort, filter and scope; `null` for any other. */
+function keysetOf(cursor, query) {
+	try {
+		const parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+		if (!Array.isArray(parsed) || parsed.length !== 5 || !parsed.every((part) => typeof part === "string")) return null;
+		const [, , , key, id] = parsed;
+		return cursorOf$1(query, key, id) === cursor ? {
+			key,
+			id
+		} : null;
+	} catch {
+		return null;
+	}
+}
+var oneOf = (allowed, value) => allowed.includes(value);
+/** The list's query, or `null` when any part of it is not one the API takes. */
+/** The page size: a whole number from 1 to the maximum, the default if none; 0 for anything else. */
+function limitOf$1(url) {
+	const raw = url.searchParams.get("limit") ?? String(LIST_LIMIT.default);
+	const limit = /^\d+$/.test(raw) ? Number(raw) : 0;
+	return limit >= 1 && limit <= LIST_LIMIT.max ? limit : 0;
+}
+function listQuery(url, scope) {
+	const limit = limitOf$1(url);
+	const archived = url.searchParams.get("archived") ?? "false";
+	const sort = url.searchParams.get("sort") ?? "updatedAt:desc";
+	if (limit === 0 || !oneOf(ARCHIVED, archived) || !oneOf(SORTS, sort)) return null;
+	const cursor = url.searchParams.get("cursor");
+	const after = cursor === null ? null : keysetOf(cursor, {
+		scope,
+		sort,
+		archived
+	});
+	return cursor !== null && after === null ? null : {
+		scope,
+		limit,
+		sort,
+		archived,
+		after
+	};
+}
+/** One page of the sessions the query selects, newest first, the id breaking ties. */
+function pageOf(sessions, query) {
+	const { scope, sort, archived, after, limit } = query;
+	const keyOf = (session) => sort === "createdAt:desc" ? session.createdAt : session.updatedAt;
+	const kept = (session) => archived === "any" || archived === "true" === (session.archivedAt !== null);
+	const beyond = (session) => after === null || keyOf(session) < after.key || keyOf(session) === after.key && session.id < after.id;
+	const matches = sessions.all().filter((session) => sameScope(session.scope, scope) && kept(session)).sort((a, b) => keyOf(b).localeCompare(keyOf(a)) || b.id.localeCompare(a.id)).filter(beyond);
+	const page = matches.slice(0, limit);
+	const hasMore = matches.length > limit;
+	const last = page.at(-1);
+	const nextCursor = hasMore && last !== void 0 ? cursorOf$1(query, keyOf(last), last.id) : null;
+	return {
+		data: page.map(summaryOf),
+		nextCursor,
+		hasMore
+	};
+}
+/** With `ids`: exactly those sessions' summaries (at most 8, in the order asked, whatever their archive state). */
+function byIds(res, ids, scope, sessions) {
+	const wanted = ids.split(",").map((id) => id.trim());
+	if (wanted.length > MAX_IDS || wanted.some((id) => id === "")) {
+		refuse(res, 400, "invalid_request", `ids is 1 to ${MAX_IDS} comma-separated session ids`);
+		return null;
+	}
+	return {
+		data: [...new Set(wanted)].map((id) => sessions.get(id)).filter((session) => session !== void 0 && sameScope(session.scope, scope)).map(summaryOf),
+		nextCursor: null,
+		hasMore: false
+	};
+}
+/** `GET /api/sessions`: the caller's sessions in the scope the query names, paged by a keyset cursor. */
+function list(req, res, url, sessions) {
+	const scope = queryScope(url);
+	if (scope === null || scope === "invalid") {
+		refuse(res, 400, "invalid_request", SCOPE_RULE);
+		return;
+	}
+	const ids = url.searchParams.get("ids");
+	if (ids !== null) {
+		const answer = byIds(res, ids, scope, sessions);
+		if (answer !== null) sendTagged(req, res, 200, answer);
+		return;
+	}
+	const query = listQuery(url, scope);
+	if (query === null) {
+		refuse(res, 400, "invalid_request", `${`limit is 1 to ${LIST_LIMIT.max}; archived is ${ARCHIVED.join(", ")}; sort is ${SORTS.join(" or ")}`}; cursor is one this API issued for the same query`);
+		return;
+	}
+	sendTagged(req, res, 200, pageOf(sessions, query));
+}
+/** `GET /api/sessions/{id}`: the session, its transcript and what it collected. */
+function read(req, res, session) {
+	sendTagged(req, res, 200, { data: transcriptOf(session) });
 }
-/** Why a message's skill is refused (agent conversations API 6.1), or `null`: it must be offered, and comes alone. */
+var PATCHABLE = /* @__PURE__ */ new Set(["title", "archived"]);
+/** A title of 1 to 80 characters once trimmed; `null` for anything else. */
+function titleOf$1(value) {
+	const title = typeof value === "string" ? value.trim() : "";
+	return title.length >= 1 && title.length <= 80 ? title : null;
+}
+/** A `PATCH` body: a title of 1 to 80 characters once trimmed, `archived`, or both; `null` for anything else. */
+function patchOf(body) {
+	if (!isObject(body) || Object.keys(body).length === 0 || !Object.keys(body).every((key) => PATCHABLE.has(key))) return null;
+	const patch = {};
+	if ("title" in body) {
+		const title = titleOf$1(body.title);
+		if (title === null) return null;
+		patch.title = title;
+	}
+	if ("archived" in body) {
+		if (typeof body.archived !== "boolean") return null;
+		patch.archived = body.archived;
+	}
+	return patch;
+}
+/** `PATCH /api/sessions/{id}`: rename or (un)archive, against the `updatedAt` the caller read (REST standard). */
+async function change(req, res, session) {
+	const since = req.headers["if-unmodified-since"];
+	if (since === void 0) {
+		refuse(res, 428, "precondition_required", "Send if-unmodified-since with the updatedAt you read");
+		return;
+	}
+	const patch = patchOf(await readJson(req));
+	if (patch === null) {
+		refuse(res, 400, "invalid_request", "The body is { title?: 1 to 80 characters, archived?: boolean }, with at least one");
+		return;
+	}
+	if (session.deleted) {
+		notFound(res);
+		return;
+	}
+	const readAt = Date.parse(since);
+	if (Number.isNaN(readAt) || readAt !== Date.parse(session.updatedAt)) {
+		refuse(res, 412, "precondition_failed", "The session changed since you read it");
+		return;
+	}
+	const updatedAt = touch(session);
+	const changed = {};
+	if (patch.title !== void 0) {
+		session.title = patch.title;
+		changed.title = patch.title;
+	}
+	if (patch.archived !== void 0) {
+		session.archivedAt = patch.archived ? session.archivedAt ?? updatedAt : null;
+		changed.archivedAt = session.archivedAt;
+	}
+	publish(session.channel, "session", {
+		...changed,
+		updatedAt
+	});
+	sendTagged(req, res, 200, { data: resourceOf(session) });
+}
+/** `DELETE /api/sessions/{id}`: gone from now on; a turn in progress stops, and every events stream ends. */
+function remove(req, res, session, sessions) {
+	sessions.remove(session.id);
+	sendJson(res, 200, { data: { id: session.id } }, contentTypeFor(req));
+}
+//#endregion
+//#region src/mock/stream.ts
+/** Where a stream starts: `Last-Event-ID` (a reconnect), else `after`; `null` for neither, `'invalid'` for a bad one. */
+function startOf(req, url) {
+	const header = req.headers["last-event-id"];
+	const raw = (typeof header === "string" ? header : void 0) ?? url.searchParams.get("after");
+	if (raw === null) return null;
+	return /^\d+$/.test(raw.trim()) ? Number(raw.trim()) : "invalid";
+}
+/**
+* `GET /api/sessions/{id}/events` (9.6): the session's events, long-lived. `after` (or `Last-Event-ID`, which wins)
+* replays what the ring still holds after it, then live events follow; with neither, live events only. `: ping` every
+* `pingMs`. A deleted session answers 410; an `after` the ring no longer reaches, 409 `events_expired`.
+*/
+function events(req, res, url, id, context) {
+	if (context.sessions.wasDeleted(id)) {
+		refuse(res, 410, "gone", "This session was deleted");
+		return;
+	}
+	const session = lookup(url, id, res, context.sessions);
+	if (session === null) return;
+	const start = startOf(req, url);
+	if (start === "invalid") {
+		refuse(res, 400, "invalid_request", "after is an event id");
+		return;
+	}
+	const replayed = replay(session.channel, start ?? session.channel.lastEventId);
+	if (replayed === "expired") {
+		refuse(res, 409, "events_expired", "Events after that id are no longer held; read the session again");
+		return;
+	}
+	res.statusCode = 200;
+	res.setHeader("Content-Type", "text/event-stream");
+	res.setHeader("Cache-Control", "no-cache");
+	res.flushHeaders();
+	for (const event of replayed) res.write(frame(event.type, event.data, event.id));
+	let open = true;
+	const ping = setInterval(() => {
+		res.write(": ping\n\n");
+	}, context.pingMs);
+	let unsubscribe = () => void 0;
+	const cleanup = () => {
+		if (open) {
+			open = false;
+			clearInterval(ping);
+			unsubscribe();
+		}
+	};
+	unsubscribe = subscribe(session.channel, {
+		send(event) {
+			res.write(frame(event.type, event.data, event.id));
+		},
+		end() {
+			cleanup();
+			res.end();
+		}
+	});
+	res.on("close", cleanup);
+}
+//#endregion
+//#region src/mock/transcript.ts
+/** The turn's answer in the transcript, made on its first event: one assistant message per turn, across its requests. */
+function answerOf(session, turn) {
+	const found = session.messages.find((message) => message.role === "assistant" && message.id === turn.answerId);
+	if (found !== void 0) return found;
+	const answer = {
+		role: "assistant",
+		id: `${turn.messageId}_a`,
+		turnId: turn.id,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		blocks: []
+	};
+	turn.answerId = answer.id;
+	session.messages.push(answer);
+	return answer;
+}
+function upsertStep(answer, step) {
+	const block = {
+		kind: "step",
+		...step
+	};
+	const index = answer.blocks.findIndex((candidate) => candidate.kind === "step" && candidate.id === step.id);
+	if (index === -1) answer.blocks.push(block);
+	else answer.blocks[index] = block;
+}
+function upsert(list, item) {
+	const index = list.findIndex((candidate) => candidate.id === item.id);
+	if (index === -1) list.push(item);
+	else list[index] = item;
+}
+/** An event's data: everything but its type. */
+function bodyOf$1(event) {
+	return Object.fromEntries(Object.entries(event).filter(([key]) => key !== "type"));
+}
+function appendText(answer, delta) {
+	const last = answer.blocks.at(-1);
+	if (last?.kind === "text") last.text += delta;
+	else answer.blocks.push({
+		kind: "text",
+		text: delta
+	});
+}
+function setMode(answer, event) {
+	answer.acting = event.acting;
+	if (event.reason === void 0) delete answer.reason;
+	else answer.reason = event.reason;
+}
+/** A block that refers to an artifact or a view, once. */
+function refer(answer, kind, id) {
+	if (!answer.blocks.some((block) => block.kind === kind && block.id === id)) answer.blocks.push({
+		kind,
+		id
+	});
+}
+/** How an event that draws something changes the turn's answer, and the session's collections. */
+function draw(session, turn, answer, event) {
+	switch (event.type) {
+		case "text":
+			appendText(answer, event.delta);
+			return;
+		case "mode":
+			setMode(answer, event);
+			return;
+		case "step":
+			upsertStep(answer, bodyOf$1(event));
+			return;
+		case "page_tool":
+			upsertStep(answer, {
+				id: event.id,
+				tool: `${event.domainId}__${event.name}`,
+				input: event.input,
+				state: "running"
+			});
+			return;
+		case "approval":
+			answer.approval = {
+				id: event.id,
+				state: "proposed"
+			};
+			return;
+		case "artifact":
+			upsert(session.artifacts, {
+				...bodyOf$1(event),
+				turnId: turn.id
+			});
+			refer(answer, "artifact", event.id);
+			return;
+		default:
+			upsert(session.views, {
+				...bodyOf$1(event),
+				turnId: turn.id
+			});
+			refer(answer, "view", event.id);
+	}
+}
+/**
+* Applies one of a turn's events to the session's transcript and collections, so a session read back (9.1) holds what
+* the person saw: text, steps (a page tool the UI ran shows as a step), the approval, artifacts, views and resources.
+*/
+function record(session, turn, event) {
+	if (event.type === "done") return;
+	if (event.type === "resource") {
+		upsert(session.resources, {
+			...bodyOf$1(event),
+			turnId: turn.id
+		});
+		return;
+	}
+	draw(session, turn, answerOf(session, turn), event);
+}
+/** The person's decision on the turn's plan, as the transcript keeps it. */
+function decide(session, turn, approve) {
+	const answer = answerOf(session, turn);
+	if (answer.approval !== void 0) answer.approval = {
+		...answer.approval,
+		state: approve ? "approved" : "declined"
+	};
+}
+//#endregion
+//#region src/mock/turns.ts
+var MAX_MESSAGE_ATTACHMENTS = 10;
+var MAX_TURN_BODY = 1048576;
+var hexId = (prefix) => `${prefix}_${randomUUID().replace(/-/g, "")}`;
+/** Why a message's skill is refused, or `null`: it must be offered, and comes alone. */
 function skillRefusal(input) {
 	if (input.kind !== "message" || input.skill === void 0) return null;
 	if (input.suggestion !== void 0 || input.markup !== void 0) return "A skill does not come with a suggestion or markup";
 	const { id } = input.skill;
 	return SEED_SKILLS.some((skill) => skill.id === id) ? null : `Unknown skill ${id}`;
 }
-/**
-* `POST /api/conversations/{id}/turns`: one request of a turn, answered with the responder's events, streamed with a
-* little pacing. An unknown id, or one in another scope, is a 404 whatever the input (agent conversations API 4).
-*/
-async function turn(req, res, id, conversations, delayMs) {
-	const body = await readBody(req);
+/** Why a message's attachments are refused, or `null`: at most 10, each this session's (9.2). */
+function attachmentRefusal(input, session) {
+	if (input.kind !== "message" || input.attachments === void 0) return null;
+	if (input.attachments.length > MAX_MESSAGE_ATTACHMENTS) return `At most ${MAX_MESSAGE_ATTACHMENTS} attachments per message`;
+	const unknown = input.attachments.find((id) => !session.attachments.has(id));
+	return unknown === void 0 ? null : `No attachment ${unknown} in this session`;
+}
+async function bodyOf(req) {
+	const raw = await readRaw(req, MAX_TURN_BODY);
+	if (raw === "too_large") return raw;
+	try {
+		return JSON.parse(raw.toString("utf8"));
+	} catch {
+		return;
+	}
+}
+/** The request and its session when the turn may run; otherwise the refusal is sent and the result is `null`. */
+async function admit(req, res, id, context) {
+	const body = await bodyOf(req);
+	if (body === "too_large") {
+		refuse(res, 413, "request_too_large", "The turn is over 1 MiB");
+		return null;
+	}
 	if (!isRequest(body)) {
 		refuse(res, 400, "invalid_request", "The body is not a turn request");
-		return;
+		return null;
 	}
-	const conversation = conversations.get(id);
-	if (conversation === void 0 || !sameScope(conversation.scope, body)) {
+	const session = context.sessions.get(id);
+	if (session === void 0 || !sameScope(session.scope, body)) {
 		notFound(res);
-		return;
+		return null;
 	}
-	const refusal = skillRefusal(body.input);
+	const refusal = skillRefusal(body.input) ?? attachmentRefusal(body.input, session);
 	if (refusal !== null) {
 		refuse(res, 400, "invalid_request", refusal);
-		return;
+		return null;
 	}
-	if (conversation.busy) {
-		refuse(res, 409, "turn_in_progress", "A turn is in progress on this conversation");
-		return;
+	if (session.busy) {
+		refuse(res, 409, "turn_in_progress", "A turn is in progress on this session");
+		return null;
 	}
-	const answer = respond(body, conversation);
-	if (!Array.isArray(answer)) {
-		refuse(res, answer.status, "not_waiting", answer.message);
-		return;
-	}
-	conversation.busy = true;
-	conversation.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		session,
+		body
+	};
+}
+/** A title from the first message: its text as a person reads it, else its skill or its files; at most 80 characters. */
+function titleOf(input, session) {
+	const skill = input.skill === void 0 ? void 0 : SEED_SKILLS.find((seeded) => seeded.id === input.skill?.id)?.title;
+	const text = stripMarkup(input.text).replace(/\s+/g, " ").trim();
+	const files = (input.attachments ?? []).flatMap((id) => {
+		const name = session.attachments.get(id)?.attachment.name;
+		return name === void 0 ? [] : [name];
+	});
+	const title = [skill ?? "", text].filter((part) => part !== "").join(": ") || files.join(", ");
+	if (title === "") return null;
+	return title.length <= 80 ? title : `${title.slice(0, 79).trimEnd()}…`;
+}
+/** A message starts a turn: its user message joins the transcript, and the attachments it sends are in use from now. */
+function startTurn(session, input) {
+	const turn = {
+		id: hexId("turn"),
+		messageId: hexId("msg"),
+		seq: 0,
+		answerId: null
+	};
+	const attachments = (input.attachments ?? []).flatMap((id) => {
+		const stored = session.attachments.get(id);
+		if (stored === void 0) return [];
+		stored.usedBy = turn.id;
+		return [stored.attachment];
+	});
+	const skill = input.skill === void 0 ? void 0 : SEED_SKILLS.find((seeded) => seeded.id === input.skill?.id);
+	const message = {
+		role: "user",
+		id: turn.messageId,
+		turnId: turn.id,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		text: input.text,
+		refs: input.refs,
+		...input.markup === void 0 ? {} : { markup: input.markup },
+		...input.suggestion === void 0 ? {} : { suggestion: input.suggestion },
+		...skill === void 0 ? {} : { skill: {
+			id: skill.id,
+			title: skill.title
+		} },
+		attachments
+	};
+	session.messages.push(message);
+	session.turn = turn;
+	return {
+		turn,
+		message
+	};
+}
+/** The page tools the UI ran, as steps every device can draw: the results close the steps the `page_tool` events opened. */
+function settledSteps(input, before) {
+	if (input.kind !== "page_tool_results" || before?.kind !== "page_tool") return [];
+	return input.results.flatMap((result) => {
+		const call = before.calls.find((candidate) => candidate.id === result.id);
+		if (call === void 0) return [];
+		const step = {
+			type: "step",
+			id: call.id,
+			tool: call.tool,
+			input: call.input
+		};
+		return [result.ok ? {
+			...step,
+			state: "done",
+			result: result.result
+		} : {
+			...step,
+			state: "error",
+			error: result.error ?? "Failed"
+		}];
+	});
+}
+function emitterOf(res, session, turn) {
+	let ended = false;
+	let gone = false;
 	res.on("close", () => {
-		conversation.busy = false;
+		if (!ended) gone = true;
 	});
 	res.statusCode = 200;
 	res.setHeader("Content-Type", "text/event-stream");
 	res.setHeader("Cache-Control", "no-cache");
-	let seq = 0;
-	for (const event of answer) {
-		if (res.destroyed) break;
-		const { type, ...data } = event;
-		seq += 1;
-		res.write(`id: ${seq}\nevent: ${type}\ndata: ${JSON.stringify(data)}\n\n`);
+	return {
+		emit(type, data, seq, hub = {
+			type,
+			data
+		}) {
+			const published = publish(session.channel, hub.type, {
+				...hub.data,
+				turnId: turn.id,
+				seq
+			});
+			if (!gone) res.write(frame(type, {
+				...data,
+				turnId: turn.id,
+				seq
+			}, published.id));
+		},
+		gone: () => gone,
+		end() {
+			ended = true;
+			res.end();
+		}
+	};
+}
+/** Sends one of the responder's events: recorded, stamped, streamed; a page tool goes to the hub as a running step. */
+function send(emitter, session, turn, event) {
+	record(session, turn, event);
+	turn.seq += 1;
+	const { type, ...data } = event;
+	if (event.type === "page_tool") {
+		const step = {
+			id: event.id,
+			tool: `${event.domainId}__${event.name}`,
+			input: event.input,
+			state: "running"
+		};
+		emitter.emit(type, data, turn.seq, {
+			type: "step",
+			data: step
+		});
+	} else emitter.emit(type, data, turn.seq);
+}
+/** Streams the answer with a little pacing; `true` when it reached `done`, `false` when stopped. */
+async function play(emitter, session, turn, events, title, delayMs) {
+	for (const event of events) {
+		if (emitter.gone() || session.deleted) return false;
+		if (event.type === "done" && title !== null) {
+			session.title = title;
+			turn.seq += 1;
+			emitter.emit("title", { title }, turn.seq);
+		}
+		send(emitter, session, turn, event);
 		await pause(delayMs);
 	}
-	conversation.busy = false;
-	res.end();
+	return true;
+}
+/** The turn a request belongs to: a message starts one; page tools' results and an approval carry on the session's. */
+function begin(session, input) {
+	if (input.kind === "message") return startTurn(session, input);
+	const turn = session.turn ?? {
+		id: hexId("turn"),
+		messageId: hexId("msg"),
+		seq: 0,
+		answerId: null
+	};
+	session.turn = turn;
+	if (input.kind === "approval") decide(session, turn, input.approve);
+	return {
+		turn,
+		message: null
+	};
+}
+/** Closes the turn's response: a deleted session says so; a stopped turn leaves the session idle, for every device. */
+function end(emitter, res, session, turn, finished) {
+	if (session.deleted) {
+		if (!emitter.gone()) res.write(frame("session.deleted", { id: session.id }));
+	} else if (!finished) {
+		session.pending = null;
+		turn.seq += 1;
+		publish(session.channel, "done", {
+			stop: "end",
+			turnId: turn.id,
+			seq: turn.seq
+		});
+	}
+	session.busy = false;
+	emitter.end();
 }
+/**
+* `POST /api/sessions/{id}/turns`: one request of a turn. A message starts a turn (`turn`, `seq` 0); a page tool's
+* results or an approval continue it: the same `turnId`, `seq` going on from where it stopped, no second `turn`. Every
+* event goes to this response and to the session's hub (so to every events stream), stamped with `turnId` and `seq`
+* and with the hub's event id as `id:`; a `page_tool` goes only to this response, and the hub gets a running `step` for
+* the same call under the same `seq` and id, so neither stream has a gap.
+*/
+async function turnRequest(req, res, id, context) {
+	const admitted = await admit(req, res, id, context);
+	if (admitted === null) return;
+	const { session, body: { input }, body } = admitted;
+	const before = session.pending;
+	const answer = respond(body, session);
+	if (!Array.isArray(answer)) {
+		refuse(res, answer.status, "not_waiting", answer.message);
+		return;
+	}
+	const { turn, message } = begin(session, input);
+	session.busy = true;
+	const updatedAt = touch(session);
+	const emitter = emitterOf(res, session, turn);
+	if (message !== null) emitter.emit("turn", { messageId: turn.messageId }, 0, {
+		type: "turn",
+		data: {
+			messageId: turn.messageId,
+			message
+		}
+	});
+	if (session.archivedAt !== null) {
+		session.archivedAt = null;
+		turn.seq += 1;
+		emitter.emit("session", {
+			archivedAt: null,
+			updatedAt
+		}, turn.seq);
+	}
+	const title = input.kind !== "message" || session.title !== null ? null : titleOf(input, session);
+	end(emitter, res, session, turn, await play(emitter, session, turn, [...settledSteps(input, before), ...answer], title, context.delayMs));
+}
+//#endregion
+//#region src/mock/chatHandler.ts
+var SKILLS_LIMIT = 50;
 /** `GET /api/prompts?domain=&mode=`: the domain's seeded prompts in the mode. */
 function prompts(url, res) {
 	const domain = url.searchParams.get("domain");
@@ -785,7 +1983,6 @@ function prompts(url, res) {
 	}
 	sendJson(res, 200, { data: { prompts: promptsFor(domain, mode) } });
 }
-var SKILLS_LIMIT = 50;
 /** A page position as an opaque cursor, and back; `null` when the cursor is not one this handler issued. */
 var cursorOf = (index) => Buffer.from(String(index)).toString("base64url");
 function indexOf(cursor) {
@@ -809,72 +2006,462 @@ function skills(url, req, res) {
 	}
 	const end = start + limit;
 	const hasMore = end < SEED_SKILLS.length;
-	const data = SEED_SKILLS.slice(start, end).map(({ id, title, description }) => {
-		return {
-			id,
-			title,
-			description
-		};
-	});
-	const body = JSON.stringify({
-		data,
+	sendTagged(req, res, 200, {
+		data: SEED_SKILLS.slice(start, end).map(({ id, title, description }) => {
+			return {
+				id,
+				title,
+				description
+			};
+		}),
 		nextCursor: hasMore ? cursorOf(end) : null,
 		hasMore
 	});
-	const etag = `"${createHash("sha256").update(body).digest("hex").slice(0, 32)}"`;
-	res.setHeader("ETag", etag);
-	if (req.headers["if-none-match"] === etag) {
-		res.statusCode = 304;
-		res.end();
-		return;
+}
+/**
+* Runs the method's action, or answers 405 naming the methods the path takes. A synchronous action answers before
+* this returns (an events stream is subscribed at once); a failure is a 500 in the envelope.
+*/
+function route(req, res, actions) {
+	const failed = () => {
+		if (res.headersSent) res.end();
+		else refuse(res, 500, "internal_error", "The mock failed");
+	};
+	const action = actions[(req.method ?? "").toLowerCase()];
+	if (action === void 0) {
+		const allowed = Object.keys(actions).map((method) => method.toUpperCase()).join(", ");
+		res.setHeader("Allow", allowed);
+		refuse(res, 405, "method_not_allowed", `Only ${allowed}`);
+		return true;
 	}
-	res.statusCode = 200;
-	res.setHeader("Content-Type", "application/json");
-	res.end(body);
+	try {
+		const pending = action();
+		if (pending instanceof Promise) pending.catch(failed);
+	} catch {
+		failed();
+	}
+	return true;
+}
+/** A path segment decoded; a malformed one stays as it is, and so names no session. */
+function decode(segment) {
+	try {
+		return decodeURIComponent(segment);
+	} catch {
+		return segment;
+	}
+}
+var SESSION = /^\/api\/sessions\/([^/]+)$/;
+var SUBRESOURCE = /^\/api\/sessions\/([^/]+)\/(turns|events|attachments|artifacts)(?:\/([^/]+))?$/;
+/** Runs `then` on the session the path names, when the request may see it. */
+var withSession = ({ res, url, context }, id, then) => async () => {
+	const session = lookup(url, id, res, context.sessions);
+	if (session !== null) await then(session);
+};
+/** `/api/sessions/{id}`: read, change, delete. */
+function sessionRoute(request, id) {
+	const { req, res, context } = request;
+	return route(req, res, {
+		get: withSession(request, id, (session) => read(req, res, session)),
+		patch: withSession(request, id, async (session) => change(req, res, session)),
+		delete: withSession(request, id, (session) => remove(req, res, session, context.sessions))
+	});
+}
+/** `/api/sessions/{id}/turns`, `…/events`, `…/attachments[/{attachmentId}]`, `…/artifacts/{artifactId}`. */
+function subresourceRoute(request, id, kind, item) {
+	const { req, res, url, context } = request;
+	if (item === void 0) switch (kind) {
+		case "turns": return route(req, res, { post: async () => turnRequest(req, res, id, context) });
+		case "events": return route(req, res, { get: () => events(req, res, url, id, context) });
+		case "attachments": return route(req, res, { post: withSession(request, id, async (session) => upload(req, res, session)) });
+		default: return false;
+	}
+	if (kind === "attachments") {
+		const action = withSession(request, id, (session) => attachmentRoute(req, res, session, item));
+		return route(req, res, {
+			get: action,
+			delete: action
+		});
+	}
+	return kind === "artifacts" && route(req, res, { get: withSession(request, id, (session) => artifactRoute(res, session, item)) });
 }
-var TURNS = /^\/api\/conversations\/([^/]+)\/turns$/;
 /**
-* The dev-only agent backend (assistant endpoints design, decision 23), speaking the agent conversations API:
-* `POST /api/conversations`, `POST /api/conversations/{id}/turns`, `GET /api/prompts` and `GET /api/skills`. Each handler keeps its own
-* conversations, in memory.
+* The dev-only agent backend (assistant endpoints design, decision 23), speaking the agent sessions API (session pane
+* design 9): sessions with their transcripts, turns, events, attachments and artifacts, and `GET /api/prompts` and `GET
+* /api/skills`. Each handler keeps its own sessions, in memory.
 */
 function createChatHandler(options = {}) {
-	const delayMs = options.delayMs ?? 40;
-	const conversations = options.conversations ?? createConversations();
-	const failed = (res) => () => {
-		if (!res.headersSent) refuse(res, 500, "internal_error", "The mock failed");
-		else res.end();
+	const context = {
+		sessions: options.sessions ?? createSessions(),
+		delayMs: options.delayMs ?? 40,
+		pingMs: options.pingMs ?? 25e3
 	};
 	return (req, res) => {
 		const url = new URL(req.url ?? "/", "http://mock.invalid");
-		const only = (method, then) => {
-			if (req.method === method) then();
-			else {
-				res.setHeader("Allow", method);
-				refuse(res, 405, "method_not_allowed", `Only ${method}`);
-			}
-			return true;
+		const request = {
+			req,
+			res,
+			url,
+			context
 		};
-		if (url.pathname === "/api/prompts") return only("GET", () => prompts(url, res));
-		if (url.pathname === "/api/skills") return only("GET", () => skills(url, req, res));
-		if (url.pathname === "/api/conversations") return only("POST", () => {
-			create(req, res, conversations).catch(failed(res));
-		});
-		const match = TURNS.exec(url.pathname);
-		if (match === null) return false;
-		return only("POST", () => {
-			turn(req, res, decodeURIComponent(match[1]), conversations, delayMs).catch(failed(res));
-		});
+		switch (url.pathname) {
+			case "/api/prompts": return route(req, res, { get: () => prompts(url, res) });
+			case "/api/skills": return route(req, res, { get: () => skills(url, req, res) });
+			case "/api/sessions": return route(req, res, {
+				get: () => list(req, res, url, context.sessions),
+				post: async () => create(req, res, context.sessions)
+			});
+		}
+		const one = SESSION.exec(url.pathname);
+		if (one !== null) return sessionRoute(request, decode(one[1]));
+		const sub = SUBRESOURCE.exec(url.pathname);
+		if (sub === null) return false;
+		return subresourceRoute(request, decode(sub[1]), sub[2], sub[3] === void 0 ? void 0 : decode(sub[3]));
 	};
 }
 //#endregion
+//#region src/mock/seedSessions.ts
+/** The dev token's scope: its org and default tenant, as the assistant names it (`runtime.ts`, `scopeOf`). */
+var DEV_SCOPE = {
+	orgId: "org_dev",
+	tenantScope: { tenantIds: ["acme"] }
+};
+var MINUTE = 6e4;
+var HOUR = 60 * MINUTE;
+var DAY = 24 * HOUR;
+var minutes = (count) => count * MINUTE;
+var days = (count, hours = 0) => count * DAY + hours * HOUR;
+/** A stable id per seed, so a tab left open across a dev-server restart still finds its session. */
+var stableId = (prefix, seed) => `${prefix}_${createHash("sha256").update(seed).digest("hex").slice(0, 32)}`;
+/** Plausible, synthetic sessions: 5 today, 8 in the previous 7 days, 12 older (assistant recent conversations design 7). */
+var SEEDS = [
+	{
+		title: "Alerts by host",
+		ago: minutes(4),
+		question: "Alerts by host",
+		reply: "web-01 raised the most alerts in the last 24 hours (42). The chart and the table hold the same counts."
+	},
+	{
+		title: "Suppress duplicate beaconing alerts",
+		ago: minutes(12),
+		question: "Suppress a4 and a5, they are duplicates of a2",
+		reply: ""
+	},
+	{
+		title: "Triage credential dumping on web-01",
+		ago: minutes(26),
+		question: "What happened on web-01 around 09:00?",
+		reply: "Two alerts fired within four minutes: credential dumping, then a new scheduled task. Both point at the same service account."
+	},
+	{
+		title: "Impossible travel for j.doe",
+		ago: minutes(41),
+		question: "Is the impossible travel alert for j.doe real?",
+		reply: "The second sign-in came from a known VPN exit. It is likely benign; the VPN log confirms the session."
+	},
+	{
+		title: "Noisy rules this week",
+		ago: minutes(55),
+		question: "Which rules were noisiest this week?",
+		reply: "Three rules account for 61 % of alerts: DNS beaconing, failed MFA bursts and new admin share access."
+	},
+	{
+		title: "Phishing report from finance",
+		ago: days(1, 2),
+		question: "Summarise the phishing report from finance",
+		reply: "One user clicked; no credentials were entered. The sender domain was registered two days ago."
+	},
+	{
+		title: "VPN gateway brute force",
+		ago: days(1, 7),
+		question: "Is vpn-gw-1 under brute force?",
+		reply: "1,840 failed logins from 12 addresses in an hour. Lockout held; no successful sign-in."
+	},
+	{
+		title: "Open investigations by owner",
+		ago: days(2),
+		question: "Who owns the open investigations?",
+		reply: "Seven are open: four with the tier-2 rota, two with you, one unassigned."
+	},
+	{
+		title: "Malware sample on build-07",
+		ago: days(3),
+		question: "What did the sandbox say about the sample on build-07?",
+		reply: "The sample is a known loader. It reached out to one address, which is now blocked."
+	},
+	{
+		title: "Weekend alert summary",
+		ago: days(3, 5),
+		question: "Summarise the weekend's alerts",
+		reply: "212 alerts, 9 critical, all triaged. Nothing is waiting on you."
+	},
+	{
+		title: "Service account review",
+		ago: days(4),
+		question: "Which service accounts logged in interactively?",
+		reply: "Two did: svc-backup and svc-report. Both from jump hosts, both within change windows."
+	},
+	{
+		title: "Mail rule forwarding outside",
+		ago: days(5),
+		question: "Find mailboxes forwarding to outside domains",
+		reply: "Three mailboxes forward externally. One rule was created yesterday from an unfamiliar address."
+	},
+	{
+		title: "Data egress from db-02",
+		ago: days(6),
+		question: "Did db-02 send unusual volumes out?",
+		reply: "Egress peaked at 3.1 GB at 02:00, matching the nightly backup to the usual target."
+	},
+	{
+		title: "New admin accounts in October",
+		ago: days(9),
+		question: "List admin accounts created in October",
+		reply: "Four were created, all through the access request flow, each with an approver."
+	},
+	{
+		title: "Endpoint isolation checklist",
+		ago: days(12),
+		question: "What do I check before isolating a laptop?",
+		reply: "Confirm the owner, that a ticket exists, and that the device is not a server; then isolate and note why."
+	},
+	{
+		title: "Lateral movement from hr-laptop-12",
+		ago: days(15),
+		question: "Did hr-laptop-12 move laterally?",
+		reply: "It reached two file shares it uses daily and nothing else. No sign of lateral movement."
+	},
+	{
+		title: "Firewall change review",
+		ago: days(18),
+		question: "Review last week's firewall changes",
+		reply: "Eleven changes, all ticketed. One opened a port wider than its ticket asked for."
+	},
+	{
+		title: "DNS tunnelling false positives",
+		ago: days(21),
+		question: "Why does the DNS tunnelling rule fire on the CDN?",
+		reply: "Long subdomains from the CDN look like encoded data. An exception for its zone would quiet it."
+	},
+	{
+		title: "Quarterly access review prep",
+		ago: days(25),
+		question: "Prepare the quarterly access review",
+		reply: "Exported 312 grants across 41 groups; 17 have not been used in 90 days."
+	},
+	{
+		title: "Ransomware tabletop notes",
+		ago: days(30),
+		question: "Summarise the ransomware tabletop",
+		reply: "Detection was quick; isolation took 40 minutes because the runbook named an old tool."
+	},
+	{
+		title: "Okta MFA fatigue alerts",
+		ago: days(34),
+		question: "Explain the MFA fatigue alerts",
+		reply: "One user got 23 pushes in ten minutes and approved none. The password was reset."
+	},
+	{
+		title: "Cloud storage made public",
+		ago: days(40),
+		question: "Which buckets were made public?",
+		reply: "One bucket, for 6 minutes, by a deploy script. It is private again."
+	},
+	{
+		title: "Old: printer beaconing",
+		ago: days(47),
+		archived: true,
+		question: "Why is the printer beaconing?",
+		reply: "Its firmware checks for updates every five minutes. Expected behaviour."
+	},
+	{
+		title: "Old: test alert cleanup",
+		ago: days(53),
+		archived: true,
+		question: "Clean up the test alerts",
+		reply: "There were 48 test alerts; all are closed."
+	},
+	{
+		title: "Old: onboarding questions",
+		ago: days(60),
+		archived: true,
+		question: "How do I read an alert's timeline?",
+		reply: "Newest at the top; each entry names its source, and a click opens the raw event."
+	}
+];
+var iso = (ms) => new Date(ms).toISOString();
+function seedTurn(session, index, seed, at) {
+	const turnId = stableId("turn", `seed-${index}`);
+	const messageId = stableId("msg", `seed-${index}`);
+	const user = {
+		role: "user",
+		id: messageId,
+		turnId,
+		createdAt: iso(at - MINUTE),
+		text: seed.question,
+		refs: [],
+		attachments: []
+	};
+	const answer = {
+		role: "assistant",
+		id: `${messageId}_a`,
+		turnId,
+		createdAt: iso(at),
+		acting: "ask",
+		blocks: seed.reply === "" ? [] : [{
+			kind: "text",
+			text: seed.reply
+		}]
+	};
+	session.messages.push(user, answer);
+	return {
+		turnId,
+		messageId
+	};
+}
+/** The session waiting on a plan: two suppressions proposed, and the mock ready to run or decline them. */
+function waitOnApproval(session, turnId, messageId) {
+	const answer = session.messages.at(-1);
+	if (answer?.role !== "assistant") return;
+	const approvalId = stableId("apr", session.id);
+	const calls = ["a4", "a5"].map((id) => {
+		return {
+			id: stableId("step", `${session.id}-${id}`),
+			tool: "lab__suppress_alert",
+			input: { id }
+		};
+	});
+	answer.acting = "plan";
+	answer.reason = "more than one change, so a plan first";
+	answer.blocks = calls.map((call) => {
+		return {
+			kind: "step",
+			id: call.id,
+			tool: call.tool,
+			input: call.input,
+			state: "awaiting-approval"
+		};
+	});
+	answer.approval = {
+		id: approvalId,
+		state: "proposed"
+	};
+	session.pending = {
+		kind: "approval",
+		id: approvalId,
+		calls
+	};
+	session.turn = {
+		id: turnId,
+		messageId,
+		seq: 3 + calls.length,
+		answerId: answer.id
+	};
+	session.user = {
+		kind: "message",
+		text: "Suppress a4 and a5, they are duplicates of a2",
+		refs: []
+	};
+}
+/**
+* The session holding a chart and a table, the four resources the harness reports, and a connector it acted through:
+* sources and actions both, so the column's two sections fill in dev.
+*/
+function collect(session, turnId) {
+	const answer = session.messages.at(-1);
+	if (answer?.role !== "assistant") return;
+	const chart = {
+		...hostChart(stableId("art", `${session.id}-chart`)),
+		turnId
+	};
+	const table = {
+		...hostTable(session.id, stableId("art", `${session.id}-table`)),
+		turnId
+	};
+	session.artifacts.push(chart, table);
+	answer.blocks.push({
+		kind: "artifact",
+		id: chart.id
+	}, {
+		kind: "artifact",
+		id: table.id
+	});
+	session.resources.push(...[
+		{
+			kind: "memory",
+			use: "source",
+			label: "Triage preferences",
+			detail: "Read 3 notes",
+			state: "done"
+		},
+		{
+			kind: "connector",
+			use: "source",
+			label: "Lab API",
+			detail: "Searched alerts",
+			state: "done"
+		},
+		{
+			kind: "agent",
+			use: "action",
+			label: "Alert triage",
+			detail: "Ranked the alerts in view",
+			state: "done"
+		},
+		{
+			kind: "workflow",
+			use: "action",
+			label: "Suppress duplicates",
+			detail: "Dry run: nothing changed",
+			state: "done"
+		},
+		{
+			kind: "connector",
+			use: "action",
+			label: "Ticketing",
+			detail: "Drafted a ticket; not filed",
+			state: "done"
+		}
+	].map((resource) => {
+		return {
+			...resource,
+			id: stableId("res", `${session.id}-${resource.kind}-${resource.use}`),
+			turnId
+		};
+	}));
+}
+/**
+* Seeds 25 sessions in the dev token's scope: 3 archived, 1 waiting on an approval, 1 holding a chart, a table and
+* five resources, updated today, in the previous 7 days and earlier. Every word in them is made up.
+*/
+function seedSessions(sessions, scope = DEV_SCOPE, now = Date.now()) {
+	for (const [index, seed] of [...SEEDS.entries()].reverse()) {
+		const at = now - seed.ago;
+		const session = sessions.create(scope, {
+			id: stableId("ses", `seed-${index}`),
+			createdAt: iso(at - 2 * MINUTE),
+			updatedAt: iso(at)
+		});
+		session.title = seed.title;
+		const { turnId, messageId } = seedTurn(session, index, seed, at);
+		if (seed.archived === true) {
+			session.archivedAt = iso(at + MINUTE);
+			session.updatedAt = session.archivedAt;
+		}
+		if (index === 0) collect(session, turnId);
+		if (index === 1) waitOnApproval(session, turnId, messageId);
+	}
+}
+//#endregion
 //#region src/mock/index.ts
 /**
-* The assistant's dev API, fresh state per call. Its own dev server and the dev host's bundled copy
-* (`@aistrike-dev/ui-shell-dev`, which loads the build of this file) both run it. Never part of the MFE's build.
+* The assistant's dev API, fresh state per call: the agent sessions API with 25 seeded sessions in the dev token's
+* scope. Its own dev server and the dev host's bundled copy (`@aistrike-dev/ui-shell-dev`, which loads the build of
+* this file) both run it. Never part of the MFE's build.
 */
 function createMockHandlers() {
-	return [createChatHandler()];
+	const sessions = createSessions();
+	seedSessions(sessions);
+	return [createChatHandler({ sessions })];
 }
 //#endregion
 export { createMockHandlers };