@bud.sh/app 0.5.1 → 0.6.0

package/dist/server/assets/{server-DxK-UB_Z.js → server-Dkbp5stG.js}

@@ -1,11 +1,11 @@
-import { $ as publishAll, $n as forkUnsafe, $t as provideContext, An as uninterruptible, At as catch_, Bn as effectDiscard, Bt as forever, Cn as tap, Ct as as$1, D as as, Dn as tryPromise, E as FileSystem, Fn as currentTimeMillis, Ft as fail$1, G as make$3, Gn as mergeAll, Gt as map, H as runForEach, Hn as isLayer, Ht as forkScoped, I as fromPubSub, In as build, It as filterOrFail, J as offerUnsafe, Jn as succeed$1, Jt as option, Kn as provide$1, Kt as mapError, L as ignore$1, Ln as buildWithMemoMap, Lt as flatMap, Mn as void_$1, N as empty$1, Nn as withFiber, Nt as die, O as callback, On as try_, Ot as catchIf, P as filter, Pn as yieldNow, Pt as ensuring, Q as publish, Qn as close, R as make$2, Rn as effect, Rt as flatten, S as writeTextAtomic, Sn as sync, St as andThen, T as Path, Tn as timeoutOption, Tt as asVoid, U as tap$1, Un as makeMemoMapUnsafe, Ut as gen, V as merge, Vn as empty, Vt as forkIn, W as unwrap$1, Wt as ignore, X as sliding$1, Xn as sync$1, Xt as orElseSucceed, Y as shutdown$1, Yt as orDie, Z as take, Zn as unwrap, Zt as promise, _n as serviceOption, _t as bytes$1, an as runFork, ar as void_, at as runIn, bn as succeedNone, bt as addFinalizer, cn as runPromiseExit, cr as add, dn as runSync, dr as getOrNull, en as provideService, er as makeUnsafe, et as shutdown, fn as runSyncExit, fr as getOrUndefined, gn as scoped, gr as TaggedError, hn as scope, hr as some, in as runCallbackWith, ir as succeed$2, it as interrupt, j as debounce, jn as uninterruptibleMask, jt as clockWith, kn as undefined_$1, kt as catchTag, ln as runPromiseExitWith, lr as getOption, m as projectModuleFile, mn as runSyncWith, mr as none, nr as doneUnsafe, nt as unbounded, on as runForkWith, or as scopeRemoveFinalizerUnsafe, pn as runSyncExitWith, pr as isNone, q as offer, rn as runCallback, rr as make$4, rt as await_, sn as runPromise, sr as Service, tn as result, tr as _await, tt as sliding, u as Git, un as runPromiseWith, ur as make$1, vn as sleep, vt as acquireRelease, w as RuntimePolicy, wn as tapError, wt as asSome, xn as suspend, xt as all, yn as succeed, zn as effectContext, zt as forEach } from "./branch-previews-ClkoJ0lM.js";
-import { $t as list, At as parseReviewSourceQuery, Cn as parseWorkValue, Ct as parseReviewDiffQuery, D as MAX_THREADS, Dn as parseMessage, En as messageDeletionRefusals, Fn as identifier, Ft as parseFileSearchQuery, G as applyReviewSelection, I as parseThreadInput, In as nonempty, Jt as isWithinDirectory, Kt as parseFileIndexQuery, L as parseThreadLinkInput, Ln as parseWork, Lt as classifyText, M as parseThreadCapabilities, Mn as parseWorkSchema, Mt as matchFileText, N as parseThreadDeleteInput, Nn as statusCategory, On as parseMessageAuthor, P as parseThreadFilter, Pn as WorkValidationError, Pt as searchPathMatches, Qt as integer, R as parseThreadReplyInput, Rn as record$1, Rt as filterFileEntries, Sn as parseWorkUpdate, Tn as messageDeletionRefusal, Tt as parseReviewHistoryQuery, V as parseThreadStatusInput, Vn as iconNames, Xt as parseFilePath, Yt as parentPath, Zt as pathHierarchy, _t as parseRecovery, an as parseWorkWorkspace, cn as parseSectionData, dn as parseWorkConnection, en as parseContract, fn as parseWorkCreate, ft as parseMutationApply, gn as parseWorkMutationResult, hn as parseWorkItemRef, i as routes, it as parseReviewActionIntent, j as parseThread, jn as fieldByRole, jt as compileSearchPattern, kn as withoutMessages, ln as parseWorkActionInput, lt as parseFileSaveRequest, mn as parseWorkItem, nn as strict$1, pn as parseWorkDetail, pt as parseMutationIntent, qt as isProtectedPath, r as parseLiveId, rt as parseReviewActionApply, st as parseReviewActionRecovery, t as RESYNC, tn as revision, vn as parseWorkQuery, vt as pathCollisionKey, wn as valueByRole, xt as parseReviewComparison, yn as parseWorkSnapshot, yt as validateMutationSelection, z as parseThreadSnapshot, zn as strict, zt as orderFileEntries } from "./events-iHpLGr3k.js";
-import { pathToFileURL } from "node:url";
-import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { $ as unwrap$1, $n as provide$1, $t as map, An as tap, At as andThen, B as ensuring$1, Bn as withFiber, Cn as scoped, Cr as TaggedError, Dn as succeedNone, En as succeed, Et as acquireRelease, Fn as try_, G as ignore$1, Gn as effect, Gt as flatMap, H as filter, Hn as currentTimeMillis, Ht as ensuring, In as undefined_$1, It as catchIf, Jn as empty, Jt as forever, K as make$1, Kt as flatten, L as debounce, Ln as uninterruptible, Lt as catchTag, M as Path, Mn as timeoutOption, Mt as asSome, N as FileSystem, Nt as asVoid, On as suspend, Ot as addFinalizer, P as as, Pn as tryPromise, Q as tap$1, Qn as mergeAll, Qt as ignore, Rn as uninterruptibleMask, Rt as catch_, Sn as scope, Sr as some, Tn as sleep, Tt as bytes$1, U as fromAsyncIterable, Un as build, Ut as fail$1, V as fail$2, Vn as yieldNow, Vt as die, W as fromPubSub, Wn as buildWithMemoMap, Wt as filterOrFail, X as runForEach, Xn as makeMemoMapUnsafe, Xt as forkScoped, Y as merge, Yn as isLayer, Yt as forkIn, Z as suspend$1, Zt as gen, _n as runPromiseWith, an as promise, ar as close, at as take, bn as runSyncExitWith, br as isNone, cn as provideService, cr as _await, ct as shutdown, dn as runCallbackWith, dr as succeed$2, dt as await_, en as mapError, et as make$2, f as PICKER_MODULE_URL, fn as runFork, fr as void_, ft as interrupt, gn as runPromiseExitWith, gr as getOption, hn as runPromiseExit, in as orElseSucceed, ir as unwrap, it as sliding$1, j as RuntimePolicy, jn as tapError, jt as as$1, k as writeTextAtomic, kn as sync, kt as all, ln as result, lr as doneUnsafe, lt as sliding, m as Git, mn as runPromise, mr as Service, nn as option, nt as offer, or as forkUnsafe, ot as publish, p as pickerModule, pn as runForkWith, pr as scopeRemoveFinalizerUnsafe, pt as runIn, qn as effectDiscard, qt as forEach, rn as orDie, rr as sync$1, rt as shutdown$1, sn as provideContext, sr as makeUnsafe, st as publishAll, t as BranchPreviews, tr as succeed$1, tt as makeUnsafe$1, u as bridgeScript, un as runCallback, ur as make$3, ut as unbounded, v as projectModuleFile, vn as runSync, vr as getOrNull, wn as serviceOption, xn as runSyncWith, xr as none, y as configPlugins, yn as runSyncExit, yr as getOrUndefined, z as empty$1, zn as void_$1, zt as clockWith } from "./branch-previews-DedrpnVR.js";
+import { $t as parseContract, An as fieldByRole, At as compileSearchPattern, Bn as iconNames, En as parseMessage, Fn as nonempty, Gt as parseFileIndexQuery, In as parseWork, It as classifyText, Jt as parentPath, Kt as isProtectedPath, Ln as record$2, Lt as filterFileEntries, Nn as WorkValidationError, Nt as searchPathMatches, Pn as identifier, Pt as parseFileSearchQuery, Qt as list, R as parseThreadSnapshot, Rn as strict, Rt as orderFileEntries, Sn as valueByRole, St as parseReviewDiffQuery, W as applyReviewSelection, Xt as pathHierarchy, Yt as parseFilePath, Zt as integer, _n as parseWorkQuery, _t as pathCollisionKey, bt as parseReviewComparison, ct as parseFileSaveRequest, dt as parseMutationApply, en as revision, fn as parseWorkDetail, ft as parseMutationIntent, gt as parseRecovery, i as routes, in as parseWorkWorkspace, j as parseThread, jn as parseWorkSchema, jt as matchFileText, kt as parseReviewSourceQuery, nt as parseReviewActionApply, ot as parseReviewActionRecovery, qt as isWithinDirectory, r as parseLiveId, rt as parseReviewActionIntent, t as RESYNC, tn as strict$1, un as parseWorkConnection, vt as validateMutationSelection, wt as parseReviewHistoryQuery } from "./events-BH_rAu7O.js";
+import { a as parseRunRecord, c as parseTaskContext, i as advanceRun, n as RUN_WAITING_STATES, o as runActive, r as RunTransitionError, s as startRun, t as NEEDS_CONTEXT_MARKER } from "./run-BJ8r5jSh.js";
+import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { closeSync, constants, fchmodSync, fstatSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, readSync, readdirSync, realpathSync, renameSync, rmdirSync, unlinkSync, writeSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { any, boolean, enum_ } from "remix/data-schema";
-import { open, realpath, stat } from "node:fs/promises";
+import { mkdir, open, readFile, realpath, rename, stat, writeFile } from "node:fs/promises";
 //#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/ManagedRuntime.js
 var TypeId = "~effect/ManagedRuntime";
 /**
@@ -323,7 +323,7 @@ var ThreadImportSchema = strict({
 	thread: any()
 });
 function history(value) {
-	let input = parseWork(record$1, value, "import.thread");
+	let input = parseWork(record$2, value, "import.thread");
 	if (!Array.isArray(input.messages) || input.messages.length === 0 || input.messages.length > 67108864 || input.messagesLoaded !== true || input.messagesTruncated !== false || input.messageCount !== input.messages.length) throw new WorkValidationError("import.thread.messages");
 	let encoder = new TextEncoder();
 	let bytes = 0;
@@ -374,755 +374,12 @@ function parseThreadImport(value) {
 		thread: history(input.thread)
 	};
 }
-//#endregion
-//#region ../work/src/server/memory-state.ts
-var expectedRevision = nonempty(256);
-var projectRoot = nonempty(4096);
-/**
-* Runs a parser over caller input, turning its failure into an `input` work error.
-* @param parse - Parses the input.
-* @returns The parsed input.
-*/
-function input$3(parse) {
-	try {
-		return parse();
-	} catch (cause) {
-		if (cause instanceof WorkError) throw cause;
-		throw new WorkError({
-			reason: "input",
-			message: "Check the supplied values.",
-			cause
-		});
-	}
-}
-/**
-* Runs a parser over stored data, turning its failure into a `storage` work error.
-* @param parse - Parses the stored data.
-* @returns The parsed data.
-*/
-function output(parse) {
-	try {
-		return parse();
-	} catch (cause) {
-		if (cause instanceof WorkError) throw cause;
-		throw new WorkError({
-			reason: "storage",
-			message: "The adapter returned invalid data.",
-			cause
-		});
-	}
-}
-/**
-* Throws a `refused` work error.
-* @param message - The reason, safe to show.
-*/
-function refused(message) {
-	throw new WorkError({
-		reason: "refused",
-		message
-	});
-}
-/**
-* Throws a `conflict` work error unless a record is still at the revision the caller saw.
-* @param current - The stored record.
-* @param revision - The caller's expected revision.
-*/
-function expected(current, revision) {
-	input$3(() => parseWork(expectedRevision, revision, "expectedRevision"));
-	if (current.revision !== revision) throw new WorkError({
-		reason: "conflict",
-		message: "This record changed. Refresh and review your changes before saving.",
-		currentRevision: current.revision
-	});
-}
-/**
-* A loaded section, cut to its limit.
-* @param items - The section's entries.
-* @param max - The most entries to return.
-* @param count - How many entries exist in all.
-* @returns The available section, truncated when more exist than it holds.
-*/
-function available(items, max, count = items.length) {
-	return {
-		state: "available",
-		items: items.slice(0, max),
-		truncated: count > max
-	};
-}
-/**
-* A section the store does not provide.
-* @returns The unsupported section.
-*/
-function unsupported$1() {
-	return {
-		state: "unsupported",
-		items: [],
-		truncated: false
-	};
-}
-/** The items, discussions and watchers behind the in-memory work and thread adapters. */
-var MemoryStore = class {
-	identity = randomUUID();
-	schema;
-	author;
-	defaults;
-	capabilities;
-	options;
-	workspaces = /* @__PURE__ */ new Map();
-	#watchers = /* @__PURE__ */ new Map();
-	seed;
-	constructor(options) {
-		this.schema = parseWorkSchema(options.schema);
-		this.author = parseMessageAuthor(options.author ?? {
-			id: "memory",
-			name: "Memory adapter",
-			email: ""
-		});
-		this.defaults = Object.fromEntries(Object.entries(options.defaults ?? {}).map(([key, value]) => {
-			let field = this.schema.fields.find((field) => field.id === key);
-			if (!field) refused("A default refers to an undeclared field.");
-			return [key, parseWorkValue(value, field, this.schema)];
-		}));
-		this.options = {
-			...options,
-			actions: { ...options.actions },
-			sections: { ...options.sections }
-		};
-		this.capabilities = parseThreadCapabilities({
-			create: this.schema.capabilities.threads,
-			reply: this.schema.capabilities.threads,
-			status: this.schema.capabilities.threads,
-			link: this.schema.capabilities.threads,
-			delete: this.schema.capabilities.threads,
-			...options.threadCapabilities,
-			sync: false,
-			edit: false
-		});
-		if (this.schema.capabilities.sync) refused("Memory storage has no remote synchronization.");
-		for (let action of this.schema.actions) if (action.kind === "custom" && !this.options.actions?.[action.id]) refused("Declare an implementation for each custom memory action.");
-		for (let id of Object.keys(this.options.actions ?? {})) if (!this.schema.actions.some((action) => action.id === id)) refused("An action implementation has no declaration.");
-		for (let id of Object.keys(this.options.sections ?? {})) if (!this.schema.sections.some((section) => section.id === id)) refused("A section implementation has no declaration.");
-		this.seed = {
-			sequence: 0,
-			items: /* @__PURE__ */ new Map(),
-			threads: /* @__PURE__ */ new Map()
-		};
-		for (let value of options.items ?? []) {
-			let item = parseWorkItem(value, this.schema);
-			if (!item.contentLoaded || !item.revision || this.seed.items.has(item.id)) refused("Seed work items need complete content and unique identities with revisions.");
-			this.seed.items.set(item.id, {
-				item,
-				activity: [],
-				activityCount: 0,
-				history: [],
-				historyCount: 0
-			});
-		}
-		for (let value of options.threads ?? []) {
-			let thread = parseThread(value);
-			if (!thread.messagesLoaded || thread.messagesTruncated || !thread.revision || this.seed.threads.has(thread.id)) refused("Seed threads need complete messages and unique identities with revisions.");
-			for (let id of thread.itemIds) this.item(this.seed, id);
-			this.seed.threads.set(thread.id, thread);
-		}
-		for (let row of this.seed.items.values()) for (let relation of row.item.relations) this.item(this.seed, relation.item.id);
-	}
-	/**
-	* Signals every write to one workspace while the stream runs.
-	* @param root - The project directory.
-	* @returns One element per write.
-	*/
-	watch(root) {
-		return callback((queue) => acquireRelease(try_({
-			try: () => {
-				let key = input$3(() => resolve(root));
-				let notify = () => void offerUnsafe(queue, void 0);
-				let watchers = this.#watchers.get(key) ?? /* @__PURE__ */ new Set();
-				this.#watchers.set(key, watchers.add(notify));
-				return () => watchers.delete(notify);
-			},
-			catch: (cause) => cause instanceof WorkError ? cause : new WorkError({
-				reason: "input",
-				message: "Invalid project directory.",
-				cause
-			})
-		}), (stop) => sync(stop)));
-	}
-	run(root, write, operation) {
-		return gen({ self: this }, function* () {
-			yield* yieldNow;
-			let now = yield* currentTimeMillis;
-			return yield* try_({
-				try: () => {
-					let key = input$3(() => {
-						parseWork(projectRoot, root, "root");
-						if (!isAbsolute(root)) throw new TypeError("The project directory must be absolute.");
-						return resolve(root);
-					});
-					let current = this.workspaces.get(key) ?? structuredClone(this.seed);
-					let data = write ? structuredClone(current) : current;
-					let result = structuredClone(operation(data, new Date(now).toISOString()));
-					if (write) {
-						this.workspaces.set(key, data);
-						for (let notify of [...this.#watchers.get(key) ?? []]) notify();
-					}
-					return result;
-				},
-				catch: (cause) => cause instanceof WorkError ? cause : new WorkError({
-					reason: "storage",
-					message: "Memory storage failed.",
-					cause
-				})
-			});
-		});
-	}
-	next(data, prefix) {
-		return `${prefix}-${this.identity}-${++data.sequence}`;
-	}
-	item(data, id) {
-		input$3(() => parseWork(identifier, id, "id"));
-		let item = data.items.get(id);
-		if (!item) throw new WorkError({
-			reason: "not-found",
-			message: "This work item does not exist."
-		});
-		return item;
-	}
-	thread(data, id) {
-		input$3(() => parseWork(identifier, id, "id"));
-		let thread = data.threads.get(id);
-		if (!thread) throw new WorkError({
-			reason: "not-found",
-			message: "This discussion does not exist."
-		});
-		return thread;
-	}
-	done(item) {
-		let status = valueByRole(item, this.schema, "status");
-		return typeof status === "string" && ["done", "cancelled"].includes(statusCategory(this.schema, status) ?? "");
-	}
-	view(data, id) {
-		let item = this.item(data, id).item;
-		let children = [...data.items.values()].filter((row) => row.item.relations.some((relation) => relation.direction === "out" && relation.item.id === id && this.schema.relations.find((kind) => kind.type === relation.type)?.kind === "parent"));
-		let discussion = [...data.threads.values()].filter((thread) => thread.itemIds.includes(id)).reduce((count, thread) => count + thread.messageCount, 0);
-		let blocked = item.relations.some((relation) => relation.direction === "out" && this.schema.relations.find((kind) => kind.type === relation.type)?.kind === "blocks" && !this.done(this.item(data, relation.item.id).item));
-		return output(() => parseWorkItem({
-			...item,
-			counts: {
-				...this.schema.capabilities.discussion ? { discussion } : {},
-				children: children.length,
-				childrenDone: children.filter((row) => this.done(row.item)).length
-			},
-			...this.schema.capabilities.ready ? { ready: !this.done(item) && !blocked } : {}
-		}, this.schema));
-	}
-	save(data, value, at, summary) {
-		let prior = data.items.get(value.id);
-		let revision = this.next(data, "revision");
-		let values = { ...value.values };
-		for (let [role, entry] of [
-			["identifier", value.id],
-			["revision", revision],
-			["updated", at],
-			...!prior ? [["created", at]] : []
-		]) {
-			let field = this.schema.fields.find((field) => field.role === role);
-			if (field) values[field.id] = entry;
-		}
-		let item = output(() => parseWorkItem({
-			...value,
-			revision,
-			values
-		}, this.schema));
-		let row = prior ?? {
-			item,
-			history: [],
-			historyCount: 0,
-			activity: [],
-			activityCount: 0
-		};
-		row.item = item;
-		data.items.set(item.id, row);
-		item = this.view(data, item.id);
-		row.item = item;
-		row.history.unshift({
-			revision,
-			author: this.author.name,
-			at,
-			item: structuredClone(item)
-		});
-		row.history = row.history.slice(0, 50);
-		row.historyCount++;
-		row.activity.unshift({
-			id: this.next(data, "activity"),
-			actor: this.author.name,
-			at,
-			verb: prior ? "changed" : "created",
-			summary
-		});
-		row.activity = row.activity.slice(0, 200);
-		row.activityCount++;
-		return item;
-	}
-	touchThreads(data, ids, at) {
-		for (let id of new Set(ids)) this.save(data, this.item(data, id).item, at, "Discussion changed");
-	}
-	initialValues(id, at, supplied) {
-		let values = {
-			...this.defaults,
-			...supplied
-		};
-		let status = fieldByRole(this.schema, "status");
-		if (status && values[status.id] === void 0 && this.schema.statuses.length) values[status.id] = this.schema.statuses[0].value;
-		for (let role of [
-			"identifier",
-			"created",
-			"updated"
-		]) {
-			let field = fieldByRole(this.schema, role);
-			if (field) values[field.id] = role === "identifier" ? id : at;
-		}
-		return values;
-	}
-};
-//#endregion
-//#region ../work/src/server/memory-threads.ts
-/**
-* The thread adapter over an in-memory store.
-* @param store - The store shared with the work adapter.
-* @returns The `ThreadAdapter` implementation.
-*/
-function memoryThreads(store) {
-	function view(thread, brief = false) {
-		let limit = brief ? 1 : 200;
-		return output(() => parseThread({
-			...thread,
-			messages: thread.messages.slice(0, limit),
-			messagesLoaded: !brief,
-			messagesTruncated: !brief && thread.messages.length > limit
-		}));
-	}
-	function save(data, thread, at, oldIds = []) {
-		let changed = {
-			...thread,
-			revision: store.next(data, "thread-revision"),
-			updatedAt: new Date(Math.max(Date.parse(at), Date.parse(thread.updatedAt))).toISOString(),
-			messageCount: thread.messages.length
-		};
-		let result = view(changed);
-		data.threads.set(changed.id, changed);
-		store.touchThreads(data, [...oldIds, ...changed.itemIds], at);
-		return result;
-	}
-	function snapshot(data, filter) {
-		let threads = [...data.threads.values()].filter((thread) => {
-			if (filter.itemId && !thread.itemIds.includes(filter.itemId)) return false;
-			let kind = thread.anchor ? "type" in thread.anchor ? "code" : "canvas" : null;
-			if (filter.anchorKind && filter.anchorKind !== kind) return false;
-			return !filter.pagePath || thread.anchor && !("type" in thread.anchor) && thread.anchor.pagePath === filter.pagePath;
-		});
-		return output(() => parseThreadSnapshot({
-			connection: {
-				state: "ready",
-				adapter: store.schema.adapter
-			},
-			capabilities: store.capabilities,
-			threads: threads.slice(0, MAX_THREADS).map((thread) => view(thread, true)),
-			truncated: threads.length > MAX_THREADS
-		}));
-	}
-	function link(root, id, ids, expectedRevision, remove) {
-		return store.run(root, true, (data, at) => {
-			if (!store.capabilities.link) refused("This adapter does not allow linking discussions.");
-			let request = input$3(() => parseThreadLinkInput({
-				itemIds: ids,
-				expectedRevision
-			}));
-			let thread = store.thread(data, id);
-			expected(thread, request.expectedRevision);
-			for (let id of request.itemIds) store.item(data, id);
-			let itemIds = remove ? thread.itemIds.filter((id) => !request.itemIds.includes(id)) : [.../* @__PURE__ */ new Set([...thread.itemIds, ...request.itemIds])];
-			if (itemIds.length > 100) refused("This discussion has too many linked work items.");
-			if (!thread.anchor && !itemIds.length) refused("An unanchored discussion needs a linked work item.");
-			return save(data, {
-				...thread,
-				itemIds
-			}, at, thread.itemIds);
-		});
-	}
-	return {
-		watch: (root) => store.watch(root),
-		list: (root, value) => store.run(root, false, (data) => snapshot(data, input$3(() => parseThreadFilter(value)))),
-		get: (root, id) => store.run(root, false, (data) => view(store.thread(data, id))),
-		create: (root, value, author) => store.run(root, true, (data, at) => {
-			if (!store.capabilities.create) refused("This adapter does not allow creating discussions.");
-			let request = input$3(() => parseThreadInput(value));
-			let trusted = input$3(() => parseMessageAuthor(author));
-			for (let id of request.itemIds) store.item(data, id);
-			return save(data, {
-				id: store.next(data, "thread"),
-				revision: null,
-				status: "open",
-				anchor: request.anchor,
-				itemIds: request.itemIds,
-				messages: [{
-					id: store.next(data, "message"),
-					body: request.body,
-					author: trusted,
-					createdAt: at,
-					parentId: null
-				}],
-				messageCount: 1,
-				messagesLoaded: true,
-				messagesTruncated: false,
-				createdAt: at,
-				updatedAt: at
-			}, at);
-		}),
-		reply: (root, id, value, author) => store.run(root, true, (data, at) => {
-			if (!store.capabilities.reply) refused("This adapter does not allow replying to discussions.");
-			let request = input$3(() => parseThreadReplyInput(value));
-			let trusted = input$3(() => parseMessageAuthor(author));
-			let thread = store.thread(data, id);
-			expected(thread, request.expectedRevision);
-			if (request.parentId && !thread.messages.some((message) => message.id === request.parentId)) refused("The reply parent must belong to this discussion.");
-			return save(data, {
-				...thread,
-				messages: [...thread.messages, {
-					id: store.next(data, "message"),
-					body: request.body,
-					author: trusted,
-					createdAt: at,
-					parentId: request.parentId
-				}]
-			}, at);
-		}),
-		setStatus: (root, id, status, expectedRevision) => store.run(root, true, (data, at) => {
-			if (!store.capabilities.status) refused("This adapter does not allow changing discussion status.");
-			let request = input$3(() => parseThreadStatusInput({
-				status,
-				expectedRevision
-			}));
-			let thread = store.thread(data, id);
-			expected(thread, request.expectedRevision);
-			return save(data, {
-				...thread,
-				status: request.status
-			}, at);
-		}),
-		deleteMessage: (root, id, value, author) => store.run(root, true, (data, at) => {
-			if (!store.capabilities.delete) refused("This adapter does not allow deleting messages.");
-			let request = input$3(() => parseThreadDeleteInput(value));
-			let trusted = input$3(() => parseMessageAuthor(author));
-			let thread = store.thread(data, id);
-			expected(thread, request.expectedRevision);
-			let refusal = messageDeletionRefusal(thread.messages, request.messageId, trusted.id);
-			if (refusal === "missing") throw new WorkError({
-				reason: "not-found",
-				message: messageDeletionRefusals.missing
-			});
-			if (refusal) refused(messageDeletionRefusals[refusal]);
-			if (thread.messages[0].id === request.messageId) {
-				data.threads.delete(id);
-				store.touchThreads(data, thread.itemIds, at);
-				return null;
-			}
-			return save(data, {
-				...thread,
-				messages: withoutMessages(thread.messages, [request.messageId])
-			}, at);
-		}),
-		link: (root, id, ids, revision) => link(root, id, ids, revision, false),
-		unlink: (root, id, ids, revision) => link(root, id, ids, revision, true)
-	};
-}
-//#endregion
-//#region ../work/src/server/memory-actions.ts
-/**
-* Computes what a declared action changes on an item, using its custom implementation or the
-* built-in status, claim and relation behaviour.
-* @param store - The memory store, with its schema, author and action implementations.
-* @param item - The item the action runs on.
-* @param action - The action's declaration.
-* @param values - The action's validated input.
-* @param at - When the action runs, for close timestamps.
-* @returns The new values or outgoing relations.
-*/
-function actionChange(store, item, action, values, at) {
-	let custom = store.options.actions?.[action.id];
-	if (custom) return custom(structuredClone({
-		item,
-		input: values,
-		schema: store.schema,
-		author: store.author
-	}));
-	let patch = {};
-	let status = fieldByRole(store.schema, "status");
-	if (action.kind === "close" || action.kind === "reopen" || action.kind === "transition") {
-		if (!status) refused("This schema has no status field.");
-		let destination = action.kind === "transition" ? values[action.input?.find((field) => field.role === "status" || field.kind === "status")?.id ?? ""] : store.schema.statuses.find((status) => action.kind === "close" ? status.category === "done" : ["unstarted", "backlog"].includes(status.category))?.value;
-		if (typeof destination !== "string" || !store.schema.statuses.some((status) => status.value === destination)) refused("This action has no valid destination status.");
-		patch[status.id] = destination;
-		let closed = fieldByRole(store.schema, "closed");
-		if (closed && action.kind === "close") patch[closed.id] = at;
-		if (closed && !closed.required && action.kind === "reopen") patch[closed.id] = null;
-		let reason = fieldByRole(store.schema, "closeReason");
-		let reasonInput = action.input?.find((field) => field.role === "closeReason");
-		if (reason && reasonInput && values[reasonInput.id] !== void 0) patch[reason.id] = values[reasonInput.id];
-		return { values: patch };
-	}
-	if (action.kind === "claim" || action.kind === "unclaim") {
-		let assignee = fieldByRole(store.schema, "assignee");
-		if (!assignee) refused("This schema has no assignee field.");
-		let current = item.values[assignee.id];
-		if (action.kind === "claim" && current !== null && current !== void 0 && current !== "" && !(Array.isArray(current) && !current.length) && !(typeof current === "string" && current === store.author.name) && !(typeof current === "object" && !Array.isArray(current) && current.id === store.author.id)) refused("This work item is already assigned.");
-		let person = {
-			id: store.author.id,
-			name: store.author.name,
-			email: store.author.email
-		};
-		let claimed = action.kind === "claim";
-		if (assignee.kind === "person") patch[assignee.id] = claimed ? person : null;
-		else if (assignee.kind === "people") patch[assignee.id] = claimed ? [person] : [];
-		else if (assignee.kind === "text") patch[assignee.id] = claimed ? person.name : "";
-		else refused("This assignee field cannot represent a claim.");
-		return { values: patch };
-	}
-	if (action.kind === "relate" || action.kind === "unrelate") {
-		let targetField = action.input?.find((field) => field.kind === "item");
-		if (!targetField) refused("A relation action requires an item input.");
-		let target = input$3(() => parseWorkItemRef(values[targetField.id]));
-		let editable = store.schema.relations.filter((relation) => relation.editable);
-		let relationField = action.input?.find((field) => field.kind === "enum");
-		let type = relationField ? values[relationField.id] : editable.length === 1 ? editable[0].type : void 0;
-		if (typeof type !== "string" || !editable.some((relation) => relation.type === type)) refused("Select an editable relation type.");
-		let remaining = item.relations.filter((relation) => !(relation.direction === "out" && relation.type === type && relation.item.id === target.id));
-		return { relations: action.kind === "unrelate" ? remaining : [...remaining, {
-			type,
-			direction: "out",
-			item: target
-		}] };
-	}
-	refused("This action needs an implementation.");
-}
-function reference(store, item) {
-	let title = valueByRole(item, store.schema, "title");
-	let status = valueByRole(item, store.schema, "status");
-	return {
-		id: item.id,
-		...typeof title === "string" ? { title: title.slice(0, 1e3) } : {},
-		...typeof status === "string" ? { status } : {}
-	};
-}
-/**
-* Rebuilds every item's incoming relations and link summaries from the outgoing ones, refusing
-* self-links and parent or blocking cycles, and saves the items that changed.
-* @param store - The memory store.
-* @param data - The project's items.
-* @param at - When the change happens.
-*/
-function reconcileRelations(store, data, at) {
-	let incoming = /* @__PURE__ */ new Map();
-	for (let row of data.items.values()) for (let relation of row.item.relations.filter((relation) => relation.direction === "out")) {
-		store.item(data, relation.item.id);
-		if (relation.item.id === row.item.id) refused("A work item cannot relate to itself.");
-		let relations = incoming.get(relation.item.id) ?? [];
-		relations.push({
-			type: relation.type,
-			direction: "in",
-			item: reference(store, row.item)
-		});
-		incoming.set(relation.item.id, relations);
-		let kind = store.schema.relations.find((kind) => kind.type === relation.type)?.kind;
-		if (kind !== "parent" && kind !== "blocks") continue;
-		let pending = [relation.item.id];
-		let seen = /* @__PURE__ */ new Set();
-		while (pending.length) {
-			let id = pending.pop();
-			if (id === row.item.id) refused("This relationship would create a cycle.");
-			if (seen.has(id)) continue;
-			seen.add(id);
-			for (let edge of store.item(data, id).item.relations) if (edge.direction === "out" && edge.type === relation.type) pending.push(edge.item.id);
-		}
-	}
-	for (let row of data.items.values()) {
-		let relations = [...row.item.relations.filter((relation) => relation.direction === "out").map((relation) => ({
-			...relation,
-			item: reference(store, store.item(data, relation.item.id).item)
-		})), ...incoming.get(row.item.id) ?? []];
-		if (JSON.stringify(row.item.relations) !== JSON.stringify(relations)) store.save(data, {
-			...row.item,
-			relations
-		}, at, "Relationships changed");
-	}
-}
-//#endregion
-//#region ../work/src/server/memory-work.ts
-var actionResult = strict({
+nonempty(256);
+nonempty(4096);
+strict({
 	values: any(),
 	relations: any()
 });
-/**
-* The work adapter over an in-memory store.
-* @param store - The store shared with the thread adapter.
-* @returns The `WorkAdapter` implementation.
-*/
-function memoryWork(store) {
-	let schema = store.schema;
-	let connection = {
-		state: "ready",
-		adapter: schema.adapter
-	};
-	function detail(data, id) {
-		let row = store.item(data, id);
-		let messages = [...data.threads.values()].filter((thread) => thread.itemIds.includes(id)).flatMap((thread) => thread.messages);
-		return output(() => parseWorkDetail({
-			connection,
-			item: store.view(data, id),
-			discussion: schema.capabilities.discussion ? available(messages, 200) : unsupported$1(),
-			history: schema.capabilities.history ? available(row.history, 50, row.historyCount) : unsupported$1(),
-			activity: schema.capabilities.activity ? available(row.activity, 200, row.activityCount) : unsupported$1()
-		}, schema));
-	}
-	function result(data, id) {
-		return output(() => parseWorkMutationResult({ item: store.view(data, id) }, schema));
-	}
-	return {
-		watch: (root) => store.watch(root),
-		describe: (root) => store.run(root, false, () => connection),
-		schema: (root) => store.run(root, false, () => schema),
-		list: (root, value) => store.run(root, false, (data) => {
-			let query = input$3(() => parseWorkQuery(value));
-			let search = query.search?.trim().toLowerCase();
-			let rows = [...data.items.values()].map((row) => row.item).filter((item) => {
-				if (query.status && valueByRole(item, schema, "status") !== query.status) return false;
-				return !search || [item.id, ...Object.values(item.values).filter((value) => typeof value === "string")].some((value) => value.toLowerCase().includes(search));
-			});
-			let items = rows.slice(0, query.limit).map((row) => {
-				let item = store.view(data, row.id);
-				return {
-					...item,
-					values: Object.fromEntries(Object.entries(item.values).filter(([key]) => schema.fields.find((field) => field.id === key)?.kind !== "markdown")),
-					contentLoaded: false
-				};
-			});
-			return output(() => parseWorkSnapshot({
-				connection,
-				items,
-				truncated: rows.length > query.limit,
-				schemaVersion: schema.adapter.version
-			}, schema));
-		}),
-		get: (root, id) => store.run(root, false, (data) => detail(data, id)),
-		section: (root, id, sectionId) => store.run(root, false, (data) => {
-			input$3(() => parseWork(identifier, sectionId, "sectionId"));
-			let item = store.view(data, id);
-			let declared = schema.sections.find((section) => section.id === sectionId);
-			if (!declared) return {
-				kind: "custom",
-				data: unsupported$1()
-			};
-			let custom = store.options.sections?.[sectionId];
-			let result;
-			if (custom) result = custom(structuredClone(item));
-			else if (declared.kind === "activity") result = {
-				kind: "activity",
-				data: schema.capabilities.activity ? available(store.item(data, id).activity, 200, store.item(data, id).activityCount) : unsupported$1()
-			};
-			else if (declared.kind === "history") result = {
-				kind: "history",
-				data: schema.capabilities.history ? available(store.item(data, id).history, 50, store.item(data, id).historyCount) : unsupported$1()
-			};
-			else if (declared.kind === "metadata") result = {
-				kind: "metadata",
-				data: available([item.extra], 1)
-			};
-			else result = {
-				kind: declared.kind,
-				data: unsupported$1()
-			};
-			return output(() => {
-				if (result.kind !== declared.kind) throw new TypeError("The section renderer changed.");
-				return parseSectionData(result, schema);
-			});
-		}),
-		create: (root, value) => store.run(root, true, (data, at) => {
-			if (!schema.capabilities.create) refused("This adapter does not allow creating work items.");
-			let request = input$3(() => parseWorkCreate(value, schema));
-			let id = store.next(data, "work");
-			store.save(data, {
-				id,
-				revision: null,
-				values: store.initialValues(id, at, request.values),
-				relations: [],
-				counts: {},
-				contentLoaded: true,
-				extra: null
-			}, at, "Work item created");
-			return result(data, id);
-		}),
-		update: (root, id, patch, expectedRevision) => store.run(root, true, (data, at) => {
-			if (!schema.capabilities.update) refused("This adapter does not allow editing work items.");
-			let request = input$3(() => parseWorkUpdate({
-				values: patch,
-				expectedRevision
-			}, schema));
-			let item = store.item(data, id).item;
-			expected(item, request.expectedRevision);
-			store.save(data, {
-				...item,
-				values: {
-					...item.values,
-					...request.values
-				}
-			}, at, "Work item updated");
-			reconcileRelations(store, data, at);
-			return result(data, id);
-		}),
-		act: (root, id, actionId, values, expectedRevision) => store.run(root, true, (data, at) => {
-			let request = input$3(() => parseWorkActionInput({
-				action: actionId,
-				input: values,
-				expectedRevision
-			}, schema));
-			let item = store.item(data, id).item;
-			expected(item, request.expectedRevision);
-			let action = schema.actions.find((action) => action.id === request.action);
-			let changed = actionChange(store, item, action, request.input, at);
-			output(() => parseWork(actionResult, changed, "actionResult"));
-			let next = {
-				...item,
-				values: {
-					...item.values,
-					...changed.values
-				},
-				relations: changed.relations ?? item.relations
-			};
-			store.save(data, next, at, action.label);
-			reconcileRelations(store, data, at);
-			return result(data, id);
-		})
-	};
-}
-//#endregion
-//#region ../work/src/server/memory.ts
-/**
-* Creates isolated work and discussion services for each layer and project root.
-* @param options - The schema, complete seed records and trusted behavior for this adapter.
-* @returns A layer with atomic in-memory writes and no filesystem or process requirements.
-*/
-function memoryAdapterLayer(options) {
-	return effectContext(try_({
-		try: () => {
-			let store = new MemoryStore(options);
-			return make$1(WorkAdapter, memoryWork(store)).pipe(add(ThreadAdapter, memoryThreads(store)));
-		},
-		catch: (cause) => new WorkError({
-			reason: "input",
-			message: "The memory adapter configuration is invalid.",
-			cause
-		})
-	}));
-}
 //#endregion
 //#region app/server/adapter-definition.ts
 /**
@@ -1146,24 +403,8 @@ function defineAdapter(definition) {
 }
 //#endregion
 //#region app/server/adapters.ts
-/** Invalid modules fail before a companion accepts requests. Causes stay on the server. */
+/** A store or design that fails before the companion serves; causes stay on the server. */
 var AdapterStartupError = class extends TaggedError("AdapterStartupError") {};
-/** Module evaluation is replaceable in tests and cached by the registry, not globally. */
-var AdapterModuleLoader = class extends Service()("bud/AdapterModuleLoader") {};
-var adapterModuleLoaderLayer = succeed$1(AdapterModuleLoader, { load: (filename) => tryPromise({
-	try: async () => {
-		let url = pathToFileURL(filename);
-		url.searchParams.set("bud", randomUUID());
-		return (await import(
-			/* @vite-ignore */
-			url.href
-)).default;
-	},
-	catch: (cause) => new AdapterStartupError({
-		message: `Could not evaluate adapter module ${filename}.`,
-		cause
-	})
-}) });
 /** The project's selected work and thread stores, its storage settings and its task design. */
 var AdapterRegistry = class extends Service()("bud/AdapterRegistry") {};
 function failure$3(message) {
@@ -1172,10 +413,10 @@ function failure$3(message) {
 		cause
 	});
 }
-function moduleFile(root, module, setting) {
+function designFile(root, module) {
 	return projectModuleFile(root, module, {
-		setting,
-		kind: setting.startsWith("storage.") ? "server" : "browser"
+		setting: "taskDesign",
+		kind: "browser"
 	}).pipe(mapError((cause) => new AdapterStartupError({
 		message: cause.message,
 		cause
@@ -1204,35 +445,34 @@ function publicConnection(definition, connection) {
 * @param project - The trusted project context, updated with public connection state before serving
 *   it.
 * @param builtIns - Explicit built-in implementations supplied by application composition.
-* @returns The registry layer; module loading and all acquired resources share its lifetime.
+* @returns The registry layer; all acquired resources share its lifetime.
 */
 function adapterRegistryLayer(project, builtIns) {
 	return unwrap(gen(function* () {
 		let root = project.root;
-		let loader = yield* AdapterModuleLoader;
 		let loaded = /* @__PURE__ */ new Map();
 		let selected = {
 			work: null,
 			threads: null
 		};
 		for (let kind of ["work", "threads"]) {
-			let module = project.config.storage[kind];
-			if (module === false) continue;
-			let key = module.startsWith("bud:") ? module : yield* moduleFile(root, module, `storage.${kind}`);
-			let definition = loaded.get(key);
+			let name = project.config.storage[kind];
+			if (name === false) continue;
+			let definition = loaded.get(name);
 			if (!definition) {
-				let value = module.startsWith("bud:") ? builtIns[module] : yield* loader.load(key);
+				let value = builtIns[name];
+				if (!value) return yield* new AdapterStartupError({ message: `No plugin provides the ${kind === "work" ? "task" : "discussion"} store ${name}.` });
 				definition = yield* try_({
 					try: () => defineAdapter(value),
-					catch: failure$3(`storage.${kind} adapter ${module} must export a valid adapter definition.`)
+					catch: failure$3(`The ${kind} store ${name} is not a valid adapter definition.`)
 				});
-				loaded.set(key, definition);
+				loaded.set(name, definition);
 			}
-			if (!definition[kind]) return yield* new AdapterStartupError({ message: `storage.${kind} adapter ${definition.id} does not provide ${kind}.` });
+			if (!definition[kind]) return yield* new AdapterStartupError({ message: `The ${kind === "work" ? "task" : "discussion"} store ${definition.id} does not provide ${kind}.` });
 			selected[kind] = definition;
 		}
 		let design = project.config.designs.tasks;
-		let taskDesignFile = design === "bud:beads" ? null : yield* moduleFile(root, design, "designs.tasks");
+		let taskDesignFile = design === "bud:beads" ? null : yield* designFile(root, design);
 		let workLayer = selected.work?.work;
 		let threadLayer = selected.threads?.threads;
 		let layers = mergeAll(workLayer ? provide$1(effect(WorkAdapter, gen(function* () {
@@ -1265,7 +505,13 @@ function adapterRegistryLayer(project, builtIns) {
 					"create",
 					"update",
 					"act"
-				], ["sync", "read"]);
+				], [
+					"sync",
+					"read",
+					"addStatuses",
+					"readItemData",
+					"writeItemData"
+				]);
 				let connection = yield* work.describe(root).pipe(flatMap((value) => try_({
 					try: () => parseWorkConnection(value),
 					catch: failure$3(`Adapter ${selected.work.id} returned an invalid work connection.`)
@@ -1315,6 +561,75 @@ function adapterRegistryLayer(project, builtIns) {
 	}));
 }
 //#endregion
+//#region app/server/attachments.ts
+/** Images that belong to tasks, such as a comment's screenshot, kept under their content's hash. */
+var Attachments = class extends Service()("bud/Attachments") {};
+var hashPattern = /^[a-f0-9]{64}$/;
+/**
+* Whether bytes are a JPEG of a size a task keeps.
+* @param bytes - The upload.
+* @returns Whether it is acceptable.
+*/
+function acceptableAttachment(bytes) {
+	return bytes.length > 3 && bytes.length <= 2097152 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255;
+}
+async function sha256(bytes) {
+	let digest = await crypto.subtle.digest("SHA-256", new Uint8Array(bytes));
+	return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+/**
+* Attachments in a store, under `attachments/<hash>.jpg`.
+* @param store - The directory or host store.
+* @returns The attachments layer.
+*/
+function attachmentsLayer(store) {
+	let failed = (message) => (cause) => new WorkError({
+		reason: "storage",
+		message,
+		cause
+	});
+	return succeed$1(Attachments, {
+		put: (bytes) => gen(function* () {
+			if (!acceptableAttachment(bytes)) return yield* new WorkError({
+				reason: "input",
+				message: "Attachments are JPEG images of at most 2 MB."
+			});
+			let hash = yield* tryPromise({
+				try: () => sha256(bytes),
+				catch: failed("Could not read the image.")
+			});
+			yield* tryPromise({
+				try: () => store.write(`attachments/${hash}.jpg`, bytes),
+				catch: failed("Could not keep the image.")
+			});
+			return hash;
+		}),
+		get: (hash) => hashPattern.test(hash) ? tryPromise({
+			try: async () => await store.read(`attachments/${hash}.jpg`) ?? null,
+			catch: failed("Could not read the image.")
+		}) : succeed(null)
+	});
+}
+/**
+* A directory as an attachment store, such as the project's cache.
+* @param directory - Where the files go.
+* @returns The store.
+*/
+function directoryAttachmentStore(directory) {
+	return {
+		async read(key) {
+			return readFile(join(directory, key)).then((bytes) => new Uint8Array(bytes), () => void 0);
+		},
+		async write(key, bytes) {
+			let path = join(directory, key);
+			await mkdir(dirname(path), { recursive: true });
+			let staged = `${path}.${process.pid}.tmp`;
+			await writeFile(staged, bytes);
+			await rename(staged, path);
+		}
+	};
+}
+//#endregion
 //#region ../live/src/server/hub.ts
 /**
 * Orders every published change into one stream per companion. Clients resume from their
@@ -1646,7 +961,7 @@ function publishDiffs(store, read, diff, external, quiet) {
 			pending = true;
 			changes++;
 		})));
-		yield* merge(make$2(void 0), merge(changed, activity.requests)).pipe(debounce(quiet), runForEach(() => pending ? andThen(sync(() => {
+		yield* merge(make$1(void 0), merge(changed, activity.requests)).pipe(debounce(quiet), runForEach(() => pending ? andThen(sync(() => {
 			pending = false;
 		}), check) : void_$1), forkScoped);
 	});
@@ -1661,13 +976,1426 @@ function publishDiffs(store, read, diff, external, quiet) {
 function storeLiveLayer(root) {
 	return effectDiscard(gen(function* () {
 		let registry = yield* AdapterRegistry;
-		let reads = yield* make$3(1);
+		let reads = yield* make$2(1);
 		yield* publishDiffs("work", reads.withPermit(readWorkspace(root, parseWorkQuery({}))), diffWorkspaces, registry.work?.watch?.(root) ?? empty$1, "250 millis");
 		let threads = registry.threads;
 		if (threads) yield* publishDiffs("threads", reads.withPermit(threads.list(root, {}).pipe(map(parseThreadSnapshot))), diffThreads, threads.watch?.(root) ?? empty$1, "400 millis");
 	}));
 }
 //#endregion
+//#region ../factory/src/server/errors.ts
+var RunErrorBase = TaggedError("RunError");
+/** A sandbox or agent failure; `retryable` when trying the same step again may work. */
+var RunError = class extends RunErrorBase {};
+//#endregion
+//#region ../factory/src/server/executor.ts
+/** The project's run executor, or null when it has no sandbox to run in. */
+var RunExecutor = class extends Service()("@bud.sh/factory/RunExecutor") {};
+//#endregion
+//#region ../factory/src/server/agent-token.ts
+var PURPOSE = "bud-tasks-read";
+function sign(secret, body) {
+	return createHmac("sha256", secret).update(`${PURPOSE}:${body}`).digest("base64url");
+}
+/**
+* The token a run's agent reads the task database with: its task and run, signed.
+* @param secret - The server's agent secret.
+* @param run - The run's id and its task's.
+* @returns The token.
+*/
+function agentToken(secret, run) {
+	let body = Buffer.from(JSON.stringify([run.taskId, run.id])).toString("base64url");
+	return `${body}.${sign(secret, body)}`;
+}
+/**
+* Reads a token an agent sent, if this server signed it.
+* @param secret - The server's agent secret.
+* @param token - What the agent sent.
+* @returns Its task and run, or null for a token this server didn't sign.
+*/
+function readAgentToken(secret, token) {
+	let [body, signature, ...rest] = token.split(".");
+	if (!body || !signature || rest.length || token.length > 2e3) return null;
+	let expected = Buffer.from(sign(secret, body));
+	let given = Buffer.from(signature);
+	if (expected.length !== given.length || !timingSafeEqual(expected, given)) return null;
+	try {
+		let value = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+		if (!Array.isArray(value) || value.length !== 2 || typeof value[0] !== "string" || typeof value[1] !== "string") return null;
+		return {
+			taskId: value[0],
+			runId: value[1]
+		};
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region ../factory/src/server/runs.ts
+var MAX_ATTEMPTS = 3;
+/**
+* Runs that can't start, for a project whose factory is off or whose store can't keep runs.
+* @param message - Why, as Start says it.
+* @returns Runs that refuse every action.
+*/
+function noRuns(message) {
+	let no = fail$1(refused(message));
+	return {
+		get: () => succeed(null),
+		start: () => no,
+		changes: () => no,
+		answer: () => no,
+		approve: () => no,
+		discard: () => no,
+		retry: () => no,
+		preview: () => succeed(null),
+		terminal: () => succeed(null),
+		touch: () => void_$1,
+		agentTask: () => succeed(null),
+		wake: () => succeed(null),
+		checkMerged: () => void_$1,
+		resume: void_$1
+	};
+}
+function refused(message) {
+	return new WorkError({
+		reason: "refused",
+		message
+	});
+}
+/**
+* A project's runs, with background work tied to the surrounding scope.
+* @param options - The project, its task store, the executor and how to tell views about changes.
+* @returns The runs; their background fibers stop with the scope, the sandboxes don't.
+*/
+function makeRuns(options) {
+	return gen(function* () {
+		let scope$2 = yield* scope;
+		let { root, factory, work, executor } = options;
+		let now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+		let newId = options.id ?? (() => crypto.randomUUID());
+		let locks = /* @__PURE__ */ new Map();
+		let following = /* @__PURE__ */ new Set();
+		let sleepAfter = options.sleepAfterMs === void 0 ? 3e5 : options.sleepAfterMs;
+		let dozes = /* @__PURE__ */ new Map();
+		let wakeLocks = /* @__PURE__ */ new Map();
+		let underway = /* @__PURE__ */ new Set();
+		let owned = (runId, step) => suspend(() => {
+			if (underway.has(runId)) return succeed(null);
+			underway.add(runId);
+			return step.pipe(ensuring(sync(() => underway.delete(runId))));
+		});
+		let readData = work.readItemData;
+		let writeData = work.writeItemData;
+		if (!readData || !writeData) return noRuns("The task store can’t keep runs; it needs item data support.");
+		let readItem = readData;
+		let writeItem = writeData;
+		function lock(taskId) {
+			let found = locks.get(taskId);
+			if (!found) locks.set(taskId, found = makeUnsafe$1(1));
+			return found;
+		}
+		function background(effect) {
+			return asVoid(forkIn(ignore(effect), scope$2));
+		}
+		let read = (taskId) => readItem(root, taskId, "budRun").pipe(flatMap(({ value, revision }) => try_({
+			try: () => ({
+				run: value === null ? null : parseRunRecord(value),
+				revision
+			}),
+			catch: (cause) => new WorkError({
+				reason: "storage",
+				message: "The task’s run is unreadable.",
+				cause
+			})
+		})));
+		function schema() {
+			return flatMap(work.schema(root), (value) => try_({
+				try: () => parseWorkSchema(value),
+				catch: (cause) => new WorkError({
+					reason: "storage",
+					message: "Invalid task schema.",
+					cause
+				})
+			}));
+		}
+		function setStatus(taskId, status, revision) {
+			return gen(function* () {
+				let current = yield* schema();
+				let field = fieldByRole(current, "status");
+				if (!field || !revision) return;
+				let values = { [field.id]: factory.statuses[status] };
+				yield* work.update(root, taskId, values, revision).pipe(catchIf((error) => error.reason === "conflict", () => flatMap(read(taskId), (fresh) => fresh.revision ? work.update(root, taskId, values, fresh.revision) : void_$1)));
+			});
+		}
+		/**
+		* Reads the run, decides the step and saves it, again if the task changed meanwhile.
+		* @param taskId - The task.
+		* @param decide - The step from the stored run.
+		* @returns The saved step.
+		*/
+		function transact(taskId, decide) {
+			return lock(taskId).withPermit(gen(function* () {
+				for (let attempt = 1;; attempt++) {
+					let { run, revision } = yield* read(taskId);
+					if (!revision) return yield* new WorkError({
+						reason: "storage",
+						message: "The task has no revision."
+					});
+					let step = yield* try_({
+						try: () => decide(run),
+						catch: (cause) => cause instanceof RunTransitionError ? refused(cause.message) : new WorkError({
+							reason: "input",
+							message: "Invalid run step.",
+							cause
+						})
+					});
+					let saved = yield* writeItem(root, taskId, "budRun", step.run, revision).pipe(map((result) => result.revision), catchIf((error) => error.reason === "conflict" && attempt < MAX_ATTEMPTS, () => void_$1));
+					if (saved === void 0) continue;
+					if (step.status) yield* setStatus(taskId, step.status, saved);
+					yield* options.changed;
+					return step;
+				}
+			}));
+		}
+		function report(taskId, event) {
+			return transact(taskId, (run) => {
+				if (!run) throw new RunTransitionError(null, event.type);
+				return advanceRun(run, event, now());
+			}).pipe(flatMap((step) => perform(taskId, step.effects)));
+		}
+		function fail(taskId, error) {
+			return report(taskId, {
+				type: "fail",
+				message: error.message,
+				retryable: error.retryable
+			});
+		}
+		function task(taskId) {
+			return gen(function* () {
+				let current = yield* schema();
+				let detail = yield* flatMap(work.get(root, taskId), (value) => try_({
+					try: () => parseWorkDetail(value, current),
+					catch: (cause) => new WorkError({
+						reason: "storage",
+						message: "Invalid task.",
+						cause
+					})
+				}));
+				let text = (role) => {
+					let value = valueByRole(detail.item, current, role);
+					return typeof value === "string" ? value : "";
+				};
+				let images = options.images ? yield* options.images(taskId) : [];
+				return {
+					id: taskId,
+					title: text("title") || taskId,
+					description: text("description"),
+					...images.length ? { images } : {}
+				};
+			});
+		}
+		function follow(taskId, run) {
+			if (!executor || following.has(run.id)) return void_$1;
+			following.add(run.id);
+			return background(executor.follow(run).pipe(runForEach((event) => report(taskId, event)), catchTag("RunError", (error) => fail(taskId, error)), ensuring(sync(() => following.delete(run.id)))));
+		}
+		function provision(taskId, runId) {
+			if (underway.has(runId)) return void_$1;
+			underway.add(runId);
+			return gen(function* () {
+				if (!executor) return;
+				let { run } = yield* read(taskId);
+				if (!run || run.id !== runId || run.state !== "provisioning") return;
+				let started = run;
+				yield* report(taskId, {
+					type: "ready",
+					...yield* executor.provision(started, yield* task(taskId), (sandbox) => ignore(report(taskId, {
+						type: "created",
+						sandbox
+					})))
+				});
+				let { run: working } = yield* read(taskId);
+				if (working?.state === "working") yield* follow(taskId, working);
+			}).pipe(catchTag("RunError", (error) => fail(taskId, error)), ensuring(sync(() => underway.delete(runId))));
+		}
+		function push(taskId) {
+			return gen(function* () {
+				if (!executor) return;
+				let { run } = yield* read(taskId);
+				if (!run || run.state !== "pushing") return;
+				if (run.asleep) {
+					yield* wake(taskId).pipe(mapError((cause) => new RunError({
+						message: cause.message,
+						retryable: true
+					})));
+					run = (yield* read(taskId)).run ?? run;
+				}
+				let commit = yield* owned(run.id, executor.push(run));
+				if (!commit) return;
+				yield* report(taskId, {
+					type: "pushed",
+					commit
+				});
+				let { run: pushed } = yield* read(taskId);
+				if (pushed?.state === "pushed" && options.onPushed) yield* ignore(options.onPushed(pushed));
+			}).pipe(catchTag("RunError", (error) => fail(taskId, error)));
+		}
+		function doze(taskId) {
+			if (!executor || sleepAfter === null) return void_$1;
+			let generation = (dozes.get(taskId) ?? 0) + 1;
+			dozes.set(taskId, generation);
+			return background(gen(function* () {
+				yield* sleep(`${sleepAfter} millis`);
+				if (dozes.get(taskId) !== generation) return;
+				dozes.delete(taskId);
+				yield* perform(taskId, (yield* transact(taskId, existing({ type: "sleep" }))).effects);
+			}));
+		}
+		function wake(taskId) {
+			let found = wakeLocks.get(taskId);
+			if (!found) wakeLocks.set(taskId, found = makeUnsafe$1(1));
+			return found.withPermit(gen(function* () {
+				dozes.set(taskId, (dozes.get(taskId) ?? 0) + 1);
+				let { run } = yield* read(taskId);
+				if (!run || !run.asleep || !executor) return run;
+				if (executor.resume) yield* executor.resume(run).pipe(mapError((cause) => new WorkError({
+					reason: cause.retryable ? "unavailable" : "refused",
+					message: cause.message,
+					cause
+				})));
+				let step = yield* transact(taskId, existing({ type: "wake" }));
+				if (RUN_WAITING_STATES.includes(step.run.state)) yield* doze(taskId);
+				return step.run;
+			}));
+		}
+		function perform(taskId, effects) {
+			return gen(function* () {
+				for (let effect of effects) {
+					let stored = (yield* read(taskId)).run;
+					if (!stored || !executor) return;
+					let run = stored;
+					let awake = map(orElseSucceed(wake(taskId), () => run), (woken) => woken ?? run);
+					switch (effect.type) {
+						case "provision":
+							yield* background(provision(taskId, run.id));
+							break;
+						case "send":
+							run = yield* awake;
+							yield* executor.send(run, effect.message).pipe(flatMap(() => follow(taskId, run)), catchTag("RunError", (error) => fail(taskId, error)));
+							break;
+						case "push":
+							yield* background(push(taskId));
+							break;
+						case "stop":
+							yield* ignore(executor.stop(run));
+							break;
+						case "destroy":
+							yield* ignore(executor.destroy(run));
+							break;
+						case "doze":
+							yield* doze(taskId);
+							break;
+						case "resume":
+							if (effect.state !== "provisioning") run = yield* awake;
+							if (effect.state === "provisioning") yield* background(provision(taskId, run.id));
+							else if (effect.state === "pushing") yield* background(push(taskId));
+							else if (effect.state === "working" || effect.state === "changes") yield* follow(taskId, run);
+					}
+				}
+			});
+		}
+		function act(taskId, decide) {
+			return gen(function* () {
+				let step = yield* transact(taskId, decide);
+				yield* perform(taskId, step.effects);
+				return step.run;
+			});
+		}
+		function existing(event) {
+			return (run) => {
+				if (!run) throw new RunTransitionError(null, event.type);
+				return advanceRun(run, event, now());
+			};
+		}
+		return {
+			get: (taskId) => map(read(taskId), (result) => result.run),
+			start: (taskId, by) => gen(function* () {
+				if (!factory.sandbox) return yield* refused("Choose a sandbox in factory.sandbox before starting tasks.");
+				if (!executor) return yield* refused(options.unavailable ?? `The sandbox ${factory.sandbox} isn’t available here.`);
+				let { title } = yield* task(taskId);
+				return yield* act(taskId, (previous) => startRun(previous, {
+					id: newId(),
+					taskId,
+					title,
+					branchPrefix: factory.branchPrefix,
+					base: "main",
+					provider: factory.sandbox,
+					harness: factory.agent.harness,
+					model: factory.agent.model,
+					by
+				}, now()));
+			}),
+			changes: (taskId, message, by) => act(taskId, existing({
+				type: "changes",
+				message,
+				by
+			})),
+			answer: (taskId, message, by) => act(taskId, existing({
+				type: "answer",
+				message,
+				by
+			})),
+			approve: (taskId, by) => act(taskId, existing({
+				type: "approve",
+				by
+			})),
+			discard: (taskId) => act(taskId, existing({ type: "discard" })),
+			retry: (taskId) => act(taskId, existing({ type: "retry" })),
+			wake,
+			preview: (taskId) => gen(function* () {
+				let { run } = yield* read(taskId);
+				let preview = executor?.preview;
+				if (!run || !preview || ![
+					"working",
+					"changes",
+					"review",
+					"needs_context",
+					"pushing"
+				].includes(run.state)) return null;
+				if (run.asleep) run = (yield* wake(taskId)) ?? run;
+				return yield* preview(run).pipe(mapError((cause) => new WorkError({
+					reason: "unavailable",
+					message: cause.message,
+					cause
+				})));
+			}),
+			terminal: (taskId) => gen(function* () {
+				let { run } = yield* read(taskId);
+				let terminal = executor?.terminal;
+				if (!run || !terminal || !run.sandbox || !runActive(run)) return null;
+				if (run.asleep) run = (yield* wake(taskId)) ?? run;
+				return yield* terminal(run).pipe(mapError((cause) => new WorkError({
+					reason: "unavailable",
+					message: cause.message,
+					cause
+				})));
+			}),
+			agentTask: (token) => gen(function* () {
+				let claim = executor?.readToken?.(token);
+				if (!claim) return null;
+				let { run } = yield* read(claim.taskId);
+				return run && run.id === claim.runId && runActive(run) ? claim.taskId : null;
+			}),
+			touch: (taskId) => gen(function* () {
+				let { run } = yield* read(taskId);
+				if (run && RUN_WAITING_STATES.includes(run.state) && !run.asleep && run.sandbox) yield* doze(taskId);
+			}),
+			checkMerged: (merged) => gen(function* () {
+				let snapshot = yield* work.list(root, { limit: 1e3 });
+				for (let item of snapshot.items) {
+					if (item.run?.state !== "pushed") continue;
+					let { run } = yield* read(item.id);
+					if (run?.state !== "pushed" || !run.pushed || !(yield* merged(run.pushed))) continue;
+					let step = yield* transact(item.id, existing({ type: "merged" })).pipe(catchIf((error) => error.reason === "refused", () => succeed(null)));
+					if (!step) continue;
+					yield* perform(item.id, step.effects);
+					if (options.onMerged) yield* ignore(options.onMerged(step.run));
+				}
+			}),
+			resume: gen(function* () {
+				if (!executor) return;
+				let current = yield* schema();
+				let field = fieldByRole(current, "status");
+				let candidates = (yield* work.list(root, { limit: 1e3 })).items.filter((item) => {
+					let status = field ? item.values[field.id] : void 0;
+					return [factory.statuses.inProgress, factory.statuses.needsApproval].includes(String(status));
+				});
+				for (let item of candidates) {
+					let { run } = yield* read(item.id);
+					if (!runActive(run) || underway.has(run.id)) continue;
+					if (RUN_WAITING_STATES.includes(run.state) && !run.asleep && run.sandbox) {
+						if (!dozes.has(item.id)) yield* doze(item.id);
+						continue;
+					}
+					if (run.state === "provisioning") yield* background(report(item.id, {
+						type: "fail",
+						message: "Bud restarted while setting up the sandbox. Retry to set it up again.",
+						retryable: true
+					}));
+					else if (run.state === "working" || run.state === "changes") yield* follow(item.id, run);
+					else if (run.state === "pushing") yield* background(push(item.id));
+				}
+			})
+		};
+	});
+}
+//#endregion
+//#region ../factory/src/server/sandbox.ts
+/**
+* A clone URL Git can use with a token: SSH remotes become their HTTPS form.
+* @param url - The project's remote URL.
+* @returns The HTTPS URL, without credentials.
+*/
+function httpsRemote(url) {
+	let ssh = /^(?:ssh:\/\/)?git@([^:/]+)[:/](.+?)(?:\.git)?\/?$/.exec(url.trim());
+	if (ssh) return `https://${ssh[1]}/${ssh[2]}.git`;
+	let parsed = new URL(url.trim());
+	parsed.username = "";
+	parsed.password = "";
+	return parsed.href;
+}
+//#endregion
+//#region ../factory/src/server/sandbox-executor.ts
+var DEFAULT_TERMINAL_PORT = 4097;
+var DEFAULT_PREVIEW_PORT = 4098;
+var AGENT_START = 6e4;
+function agentGit(remote) {
+	return {
+		GIT_CONFIG_COUNT: "1",
+		GIT_CONFIG_KEY_0: `remote.${remote}.pushurl`,
+		GIT_CONFIG_VALUE_0: "bud-agents-do-not-push://"
+	};
+}
+/**
+* The prompt a run starts with: the task, the project's instructions and the rules every run keeps.
+* @param task - The task.
+* @param run - The run, for its branch.
+* @param instructions - The project's instructions, if any.
+* @returns The prompt text.
+*/
+function runPrompt(task, run, instructions) {
+	return [
+		`Finish this task in the project checked out here, on the branch ${run.branch}.`,
+		"",
+		`# ${task.title}`,
+		"",
+		task.description.trim() || "(No description.)",
+		...task.images?.length ? ["", `Attached: ${task.images.map((image) => image.name).join(", ")}, the page as the comment saw it, with its point marked.`] : [],
+		...instructions?.trim() ? [
+			"",
+			"# Project instructions",
+			"",
+			instructions.trim()
+		] : [],
+		"",
+		"# How to work",
+		"",
+		"- Stay on the current branch; commit your work with clear messages when it is done.",
+		"- Run the project’s quick checks if there are any, and fix what you broke.",
+		"- Never push, never change git remotes, credentials or the git configuration.",
+		"- End with a short summary: what changed, and how a reviewer can see it.",
+		`- If you can't finish without something only a person knows, such as a decision, a missing text or an account, don't guess: stop, and end your reply with a last line \`${NEEDS_CONTEXT_MARKER} <your question>\`. You'll get the answer in this session.`
+	].join("\n");
+}
+/**
+* Git options and environment that give one command a push token: a credential helper answering
+* from the command's own environment, so the token is never written anywhere or seen by the agent.
+* @param token - The token, or null to use Git's own credentials.
+* @param username - The user name the Git host expects with a token.
+* @returns The options to put after `git`, and the command's environment.
+*/
+function pushCredential(token, username) {
+	if (!token) return {
+		auth: "",
+		env: {}
+	};
+	return {
+		auth: `-c credential.helper= -c 'credential.helper=!f() { test "$1" = get && printf "username=%s\\npassword=%s\\n" "$BUD_PUSH_USER" "$BUD_PUSH_TOKEN"; }; f' `,
+		env: {
+			BUD_PUSH_USER: username,
+			BUD_PUSH_TOKEN: token
+		}
+	};
+}
+/**
+* Runs in sandboxes from a provider with a harness's agent, pushing the branch on approval.
+* @param options - The provider, the harness, the project, secrets and the factory config.
+* @returns The run executor, with the live preview of a run.
+*/
+function sandboxExecutor(options) {
+	let { sandbox, factory, harness } = options;
+	let fail = (message, retryable = true, cause) => new RunError({
+		message,
+		retryable,
+		cause
+	});
+	let derive = (purpose, run) => createHmac("sha256", options.secret).update(`${purpose}:${run.id}`).digest("hex").slice(0, 32);
+	let password = (run) => derive("bud-agent", run);
+	let terminalPassword = (run) => derive("bud-terminal", run);
+	let promise = (operation, message) => tryPromise({
+		try: operation,
+		catch: (cause) => cause instanceof RunError ? cause : fail(`${message}: ${cause instanceof Error ? cause.message : String(cause)}`, true, cause)
+	});
+	let agent = (run) => gen(function* () {
+		if (!run.sandbox || !run.ports.agent) return yield* fail("The run has no agent yet.", false);
+		let port = yield* sandbox.expose(run.sandbox, run.ports.agent);
+		let { url, headers } = port.server ?? {
+			url: port.url,
+			headers: {}
+		};
+		return harness.connect({
+			url,
+			headers,
+			password: password(run)
+		}, options.fetch);
+	});
+	let head = (id) => map(sandbox.exec(id, "git rev-parse HEAD"), (result) => result.exitCode === 0 ? result.output.trim() : null);
+	let live = (client, session, checkout) => suspend$1(() => {
+		let controller = new AbortController();
+		return fromAsyncIterable(client.follow(session, () => runPromise(orElseSucceed(head(checkout), () => null)), controller.signal), (cause) => fail(`Lost the agent: ${cause instanceof Error ? cause.message : String(cause)}`, true, cause)).pipe(ensuring$1(sync(() => controller.abort())));
+	});
+	let port = (id, preferred) => sandbox.freePort ? sandbox.freePort(id) : succeed(preferred);
+	return {
+		provision: (run, task, created) => gen(function* () {
+			let id = yield* sandbox.create({
+				repository: options.repository,
+				ref: run.base.branch,
+				branch: run.branch,
+				setup: factory.setup,
+				env: {
+					...factory.dev?.env,
+					...options.env
+				},
+				secrets: options.secrets ?? [],
+				labels: {
+					run: run.id,
+					task: task.id
+				}
+			});
+			if (created) yield* created(id);
+			let dev = null;
+			if (factory.dev) {
+				dev = yield* port(id, factory.dev.port);
+				yield* sandbox.spawn(id, "dev", factory.dev.command.replaceAll("$PORT", String(dev)), { env: {
+					PORT: String(dev),
+					BUD_SANDBOX: "1",
+					FORCE_COLOR: "1"
+				} });
+			}
+			let preview = dev && options.page ? yield* gen(function* () {
+				let proxy = yield* port(id, DEFAULT_PREVIEW_PORT);
+				let directory = `"$(git rev-parse --absolute-git-dir)/bud-preview"`;
+				let file = (name, content) => `cat > ${directory}/${name} <<'BUD_FILE_END'\n${content}\nBUD_FILE_END`;
+				if ((yield* sandbox.exec(id, [
+					`mkdir -p ${directory}`,
+					file("proxy.py", "import http.client, os, socket, sys, threading\nfrom http.server import BaseHTTPRequestHandler, ThreadingHTTPServer\n\nUPSTREAM = int(sys.argv[2])\nFILES = os.environ.get('BUD_PREVIEW_FILES', '')\nPICKER = os.environ.get('BUD_PICKER_PATH', '')\nHOP = {'connection', 'keep-alive', 'proxy-connection', 'transfer-encoding', 'te', 'trailer', 'upgrade'}\n\n\ndef read(name):\n    try:\n        with open(os.path.join(FILES, name), 'rb') as file:\n            return file.read()\n    except OSError:\n        return b''\n\n\nclass Handler(BaseHTTPRequestHandler):\n    protocol_version = 'HTTP/1.1'\n\n    def log_message(self, *args):\n        pass\n\n    def headers_for_upstream(self):\n        headers = {}\n        for key, value in self.headers.items():\n            # The page's own address stays, as the dev server would see it without the proxy.\n            if key.lower() in HOP or key.lower() == 'accept-encoding':\n                continue\n            headers[key] = value\n        return headers\n\n    def tunnel(self):\n        upstream = socket.create_connection(('127.0.0.1', UPSTREAM))\n        lines = ['%s %s HTTP/1.1' % (self.command, self.path)]\n        for key, value in self.headers.items():\n            lines.append('%s: %s' % (key, value))\n        upstream.sendall(('\\r\\n'.join(lines) + '\\r\\n\\r\\n').encode('latin-1'))\n        client = self.connection\n\n        def pipe(source, target):\n            try:\n                while True:\n                    data = source.recv(65536)\n                    if not data:\n                        break\n                    target.sendall(data)\n            except OSError:\n                pass\n            finally:\n                for end in (source, target):\n                    try:\n                        end.shutdown(socket.SHUT_RDWR)\n                    except OSError:\n                        pass\n\n        threading.Thread(target=pipe, args=(upstream, client), daemon=True).start()\n        pipe(client, upstream)\n        self.close_connection = True\n\n    def forward(self):\n        if self.headers.get('Upgrade'):\n            return self.tunnel()\n        length = int(self.headers.get('Content-Length') or 0)\n        body = self.rfile.read(length) if length else None\n        connection = http.client.HTTPConnection('127.0.0.1', UPSTREAM, timeout=300)\n        try:\n            connection.request(self.command, self.path, body=body, headers=self.headers_for_upstream())\n            response = connection.getresponse()\n        except OSError:\n            self.send_response(502)\n            self.send_header('Content-Length', '0')\n            self.end_headers()\n            return\n        path = self.path.split('?')[0]\n        # The picker Bud's page bridge imports, when the project serves none of its own; a dev\n        # server may answer an unknown path with its page instead of a 404.\n        script = 'javascript' in (response.getheader('Content-Type') or '')\n        if PICKER and path == PICKER and (response.status != 200 or not script):\n            response.read()\n            data = read('picker.js')\n            self.send_response(200)\n            self.send_header('Content-Type', 'text/javascript')\n            self.send_header('Content-Length', str(len(data)))\n            self.end_headers()\n            self.wfile.write(data)\n            return\n        html = (response.getheader('Content-Type') or '').startswith('text/html')\n        self.send_response(response.status, response.reason)\n        for key, value in response.getheaders():\n            if key.lower() in HOP or key.lower() in ('content-length', 'server', 'date'):\n                continue\n            # A redirect to the dev server's own address stays on the page's.\n            if key.lower() == 'location':\n                for local in ('http://127.0.0.1:%d' % UPSTREAM, 'http://localhost:%d' % UPSTREAM):\n                    if value.startswith(local):\n                        value = value[len(local):] or '/'\n            self.send_header(key, value)\n        if html or self.command == 'HEAD':\n            data = response.read()\n            if html:\n                script = b'<script type=\"module\">' + read('bridge.js') + b'<\/script>'\n                head = data.lower().find(b'<head>')\n                data = data[: head + 6] + script + data[head + 6 :] if head >= 0 else script + data\n            self.send_header('Content-Length', str(len(data)))\n            self.end_headers()\n            if self.command != 'HEAD':\n                self.wfile.write(data)\n            return\n        if response.status in (204, 304) or response.status < 200:\n            self.send_header('Content-Length', '0')\n            self.end_headers()\n            return\n        self.send_header('Transfer-Encoding', 'chunked')\n        self.end_headers()\n        try:\n            while True:\n                chunk = response.read1(65536) if hasattr(response, 'read1') else response.read(65536)\n                if not chunk:\n                    break\n                self.wfile.write(b'%x\\r\\n%s\\r\\n' % (len(chunk), chunk))\n                self.wfile.flush()\n            self.wfile.write(b'0\\r\\n\\r\\n')\n        except OSError:\n            self.close_connection = True\n\n    do_GET = do_POST = do_PUT = do_PATCH = do_DELETE = do_OPTIONS = do_HEAD = forward\n\n\nif __name__ == '__main__':\n    ThreadingHTTPServer.daemon_threads = True\n    ThreadingHTTPServer(('127.0.0.1', int(sys.argv[1])), Handler).serve_forever()\n"),
+					file("bridge.js", options.page.bridge),
+					file("picker.js", options.page.picker)
+				].join("\n"))).exitCode !== 0) return null;
+				yield* sandbox.spawn(id, "preview", `BUD_PREVIEW_FILES=${directory} exec python3 ${directory}/proxy.py ${proxy} ${dev}`, { env: { BUD_PICKER_PATH: options.page.pickerPath } });
+				return proxy;
+			}).pipe(orElseSucceed(() => null)) : null;
+			let agentPort = yield* port(id, harness.port);
+			let started = {
+				...run,
+				sandbox: id,
+				ports: {
+					dev,
+					agent: agentPort,
+					...preview ? { preview } : {}
+				}
+			};
+			let tools = options.tools?.();
+			let server = harness.start({
+				port: agentPort,
+				password: password(started),
+				...tools ? { tools: {
+					url: tools,
+					token: agentToken(options.secret, {
+						id: run.id,
+						taskId: task.id
+					})
+				} } : {}
+			});
+			yield* sandbox.spawn(id, "agent", server.command, { env: {
+				...server.env,
+				...agentGit(factory.push.remote)
+			} });
+			let terminal = yield* gen(function* () {
+				let bridgePort = yield* port(id, DEFAULT_TERMINAL_PORT);
+				let file = `"$(git rev-parse --absolute-git-dir)/bud-terminal.py"`;
+				if ((yield* sandbox.exec(id, `cat > ${file} <<'BUD_TERMINAL'\nimport base64, fcntl, json, os, pty, select, signal, struct, sys, termios, threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+PASSWORD = os.environ.pop('BUD_TERMINAL_PASSWORD', '')
+LIMIT = 512 * 1024
+sessions = {}
+lock = threading.Lock()
+
+
+def clamp(value):
+    return max(2, min(int(value), 1000))
+
+
+class Session:
+    def __init__(self, command, cols, rows, env):
+        self.buffer = bytearray()
+        self.start = 0
+        self.done = False
+        self.changed = threading.Condition()
+        pid, fd = pty.fork()
+        if pid == 0:
+            # The size is set before the command starts, so it never reads an empty one.
+            fcntl.ioctl(0, termios.TIOCSWINSZ, struct.pack('HHHH', clamp(rows), clamp(cols), 0, 0))
+            os.environ.update(env)
+            os.environ['TERM'] = 'xterm-256color'
+            os.environ['COLORTERM'] = 'truecolor'
+            os.execvp('sh', ['sh', '-c', command])
+        self.pid = pid
+        self.fd = fd
+        self.resize(cols, rows)
+        threading.Thread(target=self.read, daemon=True).start()
+
+    def read(self):
+        while True:
+            try:
+                ready, _, _ = select.select([self.fd], [], [], 1)
+                if not ready:
+                    continue
+                data = os.read(self.fd, 65536)
+            except OSError:
+                data = b''
+            with self.changed:
+                if not data:
+                    self.done = True
+                    self.changed.notify_all()
+                    return
+                self.buffer += data
+                if len(self.buffer) > LIMIT:
+                    drop = len(self.buffer) - LIMIT
+                    del self.buffer[:drop]
+                    self.start += drop
+                self.changed.notify_all()
+
+    def resize(self, cols, rows):
+        fcntl.ioctl(self.fd, termios.TIOCSWINSZ, struct.pack('HHHH', clamp(rows), clamp(cols), 0, 0))
+
+    def write(self, data):
+        view = memoryview(data)
+        while view:
+            written = os.write(self.fd, view)
+            view = view[written:]
+
+    def close(self):
+        try:
+            os.killpg(os.getpgid(self.pid), signal.SIGHUP)
+        except OSError:
+            pass
+
+
+class Handler(BaseHTTPRequestHandler):
+    protocol_version = 'HTTP/1.1'
+
+    def log_message(self, *args):
+        pass
+
+    def authorized(self):
+        expected = 'Basic ' + base64.b64encode(('bud:' + PASSWORD).encode()).decode()
+        if PASSWORD and self.headers.get('Authorization') == expected:
+            return True
+        self.send_response(401)
+        self.send_header('Content-Length', '0')
+        self.end_headers()
+        return False
+
+    def reply(self, status, body=None):
+        data = json.dumps(body).encode() if body is not None else b''
+        self.send_response(status)
+        self.send_header('Content-Type', 'application/json')
+        self.send_header('Content-Length', str(len(data)))
+        self.end_headers()
+        self.wfile.write(data)
+
+    def body(self):
+        length = int(self.headers.get('Content-Length') or 0)
+        return self.rfile.read(length) if length else b''
+
+    def session(self, query):
+        name = query.get('id', '')
+        with lock:
+            return sessions.get(name)
+
+    def query(self):
+        from urllib.parse import parse_qs, urlparse
+        url = urlparse(self.path)
+        return url.path, {key: values[0] for key, values in parse_qs(url.query).items()}
+
+    def do_GET(self):
+        if not self.authorized():
+            return
+        path, query = self.query()
+        if path == '/health':
+            return self.reply(200, {'ok': True})
+        if path != '/stream':
+            return self.reply(404)
+        session = self.session(query)
+        if not session:
+            return self.reply(404)
+        offset = int(query.get('from') or 0)
+        self.send_response(200)
+        self.send_header('Content-Type', 'text/event-stream')
+        self.send_header('Cache-Control', 'no-store')
+        self.send_header('Transfer-Encoding', 'chunked')
+        self.end_headers()
+
+        def send(text):
+            data = text.encode()
+            self.wfile.write(b'%x\\r\\n%s\\r\\n' % (len(data), data))
+            self.wfile.flush()
+
+        try:
+            send(': connected\\n\\n')
+            while True:
+                with session.changed:
+                    end = session.start + len(session.buffer)
+                    while offset >= end and not session.done:
+                        if not session.changed.wait(15):
+                            break
+                        end = session.start + len(session.buffer)
+                    begin = max(offset, session.start)
+                    chunk = bytes(session.buffer[begin - session.start:end - session.start])
+                    done = session.done and begin >= end
+                if chunk:
+                    send('id: %d\\ndata: %s\\n\\n' % (end, base64.b64encode(chunk).decode()))
+                    offset = end
+                elif done:
+                    send('event: exit\\ndata: {}\\n\\n')
+                    break
+                else:
+                    send(': keepalive\\n\\n')
+            self.wfile.write(b'0\\r\\n\\r\\n')
+        except (BrokenPipeError, ConnectionResetError):
+            pass
+
+    def do_POST(self):
+        if not self.authorized():
+            return
+        path, query = self.query()
+        body = self.body()
+        if path == '/open':
+            spec = json.loads(body or b'{}')
+            name = str(spec.get('id', ''))
+            with lock:
+                existing = sessions.get(name)
+                if existing and not existing.done:
+                    return self.reply(200, {'opened': False})
+                env = spec.get('env') or {}
+                sessions[name] = Session(
+                    str(spec['command']),
+                    spec.get('cols', 80),
+                    spec.get('rows', 24),
+                    {str(key): str(value) for key, value in env.items()},
+                )
+            return self.reply(200, {'opened': True})
+        session = self.session(query)
+        if not session:
+            return self.reply(404)
+        if path == '/input':
+            session.write(body)
+            return self.reply(204)
+        if path == '/resize':
+            size = json.loads(body or b'{}')
+            session.resize(size.get('cols', 80), size.get('rows', 24))
+            return self.reply(204)
+        if path == '/close':
+            session.close()
+            return self.reply(204)
+        return self.reply(404)
+
+
+if __name__ == '__main__':
+    ThreadingHTTPServer.daemon_threads = True
+    ThreadingHTTPServer(('127.0.0.1', int(sys.argv[1])), Handler).serve_forever()
+\nBUD_TERMINAL`)).exitCode !== 0) return null;
+				yield* sandbox.spawn(id, "terminal", `exec python3 ${file} ${bridgePort}`, { env: { BUD_TERMINAL_PASSWORD: terminalPassword(started) } });
+				return bridgePort;
+			}).pipe(orElseSucceed(() => null));
+			started = {
+				...started,
+				ports: {
+					...started.ports,
+					...terminal ? { terminal } : {}
+				}
+			};
+			let client = yield* agent(started);
+			let instructions = options.instructions ? yield* options.instructions : null;
+			return {
+				sandbox: id,
+				session: yield* promise(async () => {
+					let until = Date.now() + AGENT_START;
+					while (!await client.healthy()) {
+						if (Date.now() > until) throw fail("The agent didn’t start within a minute.");
+						await new Promise((resolve) => setTimeout(resolve, 500));
+					}
+					let session = await client.session(task.title);
+					await client.prompt(session, runPrompt(task, run, instructions), task.images);
+					return session;
+				}, "Could not start the agent"),
+				commit: yield* head(id),
+				ports: started.ports
+			};
+		}),
+		follow: (run) => unwrap$1(gen(function* () {
+			let client = yield* agent(run);
+			let session = run.session;
+			if (!session) return fail$2(fail("The run has no agent session.", false));
+			let checkout = run.sandbox;
+			return live(client, session, checkout);
+		})),
+		send: (run, message) => gen(function* () {
+			let client = yield* agent(run);
+			if (!run.session) return yield* fail("The run has no agent session.", false);
+			let session = run.session;
+			yield* promise(() => client.prompt(session, `${message}\n\nKeep working on the same branch, commit, and end with a short summary.`), "Could not reach the agent");
+		}),
+		push: (run) => gen(function* () {
+			if (!run.sandbox) return yield* fail("The run has no sandbox.", false);
+			let id = run.sandbox;
+			let commit = yield* head(id);
+			if (!commit) return yield* fail("The branch has no commit to push.", false);
+			let { remote } = factory.push;
+			let ref = `refs/heads/${run.branch}`;
+			let token = options.pushToken ?? null;
+			let { auth, env } = pushCredential(token, factory.push.username);
+			let hide = (text) => token ? text.split(token).join("•••") : text;
+			let git = (command) => sandbox.exec(id, `git ${auth}${command}`, {
+				env,
+				timeoutMs: 12e4
+			});
+			let remoteHead = () => map(git(`ls-remote '${remote}' '${ref}'`), (result) => result.exitCode === 0 ? result.output.trim().split(/\s+/)[0] ?? "" : null);
+			if ((yield* remoteHead()) === commit) return commit;
+			let pushed = yield* git(`push '${remote}' 'HEAD:${ref}'`);
+			if (pushed.exitCode === 0) return commit;
+			if ((yield* remoteHead()) === commit) return commit;
+			return yield* fail(`The push was refused: ${hide(pushed.output.trim().slice(-400))}`, true);
+		}),
+		stop: (run) => run.sandbox ? sandbox.stop(run.sandbox) : void_$1,
+		resume: (run) => gen(function* () {
+			if (!run.sandbox) return yield* fail("The run has no sandbox.", false);
+			yield* sandbox.resume(run.sandbox);
+			let client = yield* agent(run);
+			yield* promise(async () => {
+				let until = Date.now() + AGENT_START;
+				while (!await client.healthy()) {
+					if (Date.now() > until) throw fail("The agent didn’t start again within a minute.");
+					await new Promise((resolve) => setTimeout(resolve, 500));
+				}
+			}, "Could not wake the agent");
+		}),
+		destroy: (run) => run.sandbox ? sandbox.destroy(run.sandbox) : void_$1,
+		readToken: (token) => readAgentToken(options.secret, token),
+		terminal: (run) => gen(function* () {
+			if (!run.sandbox || !run.ports.terminal) return null;
+			let id = run.sandbox;
+			let port = yield* sandbox.expose(id, run.ports.terminal);
+			let { url, headers } = port.server ?? {
+				url: port.url,
+				headers: {}
+			};
+			let attach = run.session && run.ports.agent && harness.attach ? harness.attach({
+				port: run.ports.agent,
+				password: password(run),
+				session: run.session
+			}) : null;
+			let log = factory.dev ? sandbox.logFile?.(id, "dev") : void 0;
+			return {
+				url,
+				headers,
+				password: terminalPassword(run),
+				sessions: {
+					agent: attach,
+					dev: log ? {
+						command: `exec tail -n 400 -F "${log}"`,
+						env: {}
+					} : null,
+					shell: {
+						command: "exec \"${SHELL:-/bin/sh}\" -i",
+						env: {}
+					}
+				}
+			};
+		}),
+		preview: (run) => run.sandbox && run.ports.dev ? map(sandbox.expose(run.sandbox, run.ports.preview ?? run.ports.dev, { public: true }), ({ url }) => {
+			let page = new URL(url);
+			page.pathname = factory.dev?.path ?? "/";
+			return { url: page.href };
+		}) : succeed(null)
+	};
+}
+//#endregion
+//#region ../harness-opencode/src/opencode.server.ts
+/**
+* Splits a configured model into OpenCode's provider and model.
+* @param model - Such as `deepseek/deepseek-v4.1-flash`.
+* @returns The provider and model ids.
+*/
+function opencodeModel(model) {
+	let slash = model.indexOf("/");
+	if (slash < 1 || slash === model.length - 1) throw new TypeError(`The model ${model} must be provider/model.`);
+	return {
+		providerID: model.slice(0, slash),
+		modelID: model.slice(slash + 1)
+	};
+}
+/**
+* OpenCode's config for an agent working in a sandbox: it may edit and run commands without asking,
+* since nothing leaves the sandbox until a person approves.
+* @param model - The configured model.
+* @param tools - Bud's task database as an MCP server, when the sandbox reaches it.
+* @returns The config as `OPENCODE_CONFIG_CONTENT` takes it.
+*/
+function opencodeConfig(model, tools) {
+	return JSON.stringify({
+		$schema: "https://opencode.ai/config.json",
+		model,
+		permission: {
+			edit: "allow",
+			bash: "allow",
+			webfetch: "allow"
+		},
+		autoupdate: false,
+		share: "disabled",
+		...tools ? { mcp: { bud: {
+			type: "remote",
+			url: tools.url,
+			headers: { Authorization: `Bearer ${tools.token}` },
+			enabled: true
+		} } } : {}
+	});
+}
+/**
+* A client for one `opencode serve`.
+* @param options - Its URL and password.
+* @returns Health, sessions, prompts and its event stream.
+*/
+function opencodeClient(options) {
+	let request = options.fetch ?? fetch;
+	let base = options.url.replace(/\/$/, "");
+	let headers = {
+		...options.headers,
+		Authorization: `Basic ${btoa(`opencode:${options.password}`)}`,
+		"Content-Type": "application/json"
+	};
+	let address = (path) => {
+		let url = new URL(base);
+		url.pathname = `${url.pathname.replace(/\/$/, "")}${path}`;
+		return url.href;
+	};
+	async function call(path, init = {}) {
+		let response = await request(address(path), {
+			...init,
+			headers: {
+				...headers,
+				...init.headers
+			}
+		});
+		if (!response.ok) throw new Error(`OpenCode answered ${response.status} for ${path}: ${(await response.text()).slice(0, 300)}`);
+		return response;
+	}
+	return {
+		async healthy() {
+			return request(address("/global/health"), { headers }).then((response) => response.ok, () => false);
+		},
+		async session(title) {
+			let session = await (await call("/session", {
+				method: "POST",
+				body: JSON.stringify({ title })
+			})).json();
+			if (typeof session.id !== "string") throw new Error("OpenCode returned no session.");
+			return session.id;
+		},
+		async prompt(session, model, text, files = []) {
+			let path = `/session/${encodeURIComponent(session)}`;
+			let count = async () => {
+				let messages = await (await call(`${path}/message`)).json();
+				return Array.isArray(messages) ? messages.length : 0;
+			};
+			let before = await count();
+			await call(`${path}/prompt_async`, {
+				method: "POST",
+				body: JSON.stringify({
+					model,
+					parts: [{
+						type: "text",
+						text
+					}, ...files.map((file) => ({
+						type: "file",
+						mime: file.mime,
+						filename: file.name,
+						url: `data:${file.mime};base64,${file.data}`
+					}))]
+				})
+			});
+			for (let tries = 0; tries < 60; tries++) {
+				if (await count() > before) return;
+				await new Promise((resolve) => setTimeout(resolve, 250));
+			}
+		},
+		async turn(session) {
+			if (record$1(record$1(await (await call("/session/status")).json())[session]).type === "busy") return { state: "working" };
+			let messages = await (await call(`/session/${encodeURIComponent(session)}/message`)).json();
+			let list = Array.isArray(messages) ? messages.map((message) => record$1(message)) : [];
+			let info = record$1(list.at(-1)?.info);
+			if (info.role === "user" || info.role === "assistant" && !record$1(info.time).completed) return { state: "working" };
+			let error = record$1(info.error);
+			if (Object.keys(error).length) {
+				let data = record$1(error.data);
+				return {
+					state: "failed",
+					message: typeof data.message === "string" ? data.message : String(error.name ?? ""),
+					retryable: data.isRetryable === true
+				};
+			}
+			for (let message of list.toReversed()) {
+				if (record$1(message.info).role !== "assistant") continue;
+				let text = replyText(message.parts);
+				if (text) return {
+					state: "done",
+					summary: text
+				};
+			}
+			return {
+				state: "done",
+				summary: ""
+			};
+		},
+		async *events(signal) {
+			let response = await call("/event", {
+				headers: { Accept: "text/event-stream" },
+				signal
+			});
+			yield {
+				type: "bud.subscribed",
+				properties: {}
+			};
+			let reader = response.body.getReader();
+			let decoder = new TextDecoder();
+			let buffer = "";
+			try {
+				while (true) {
+					let { done, value } = await reader.read();
+					if (done) return;
+					buffer += decoder.decode(value, { stream: true });
+					let blocks = buffer.split("\n\n");
+					buffer = blocks.pop() ?? "";
+					for (let block of blocks) {
+						let data = block.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+						if (!data) continue;
+						try {
+							let event = JSON.parse(data);
+							if (event && typeof event.type === "string") yield event;
+						} catch {}
+					}
+				}
+			} finally {
+				await reader.cancel().catch(() => {});
+			}
+		}
+	};
+}
+function replyText(parts) {
+	return Array.isArray(parts) ? parts.map((part) => record$1(part)).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n").trim() : "";
+}
+/**
+* Reads an untrusted JSON value as an object.
+* @param value - Anything.
+* @returns The object, or an empty one.
+*/
+function record$1(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+/**
+* Turns OpenCode's events into a run's: completed tool calls as activity, the agent's last reply as
+* its summary when the session is idle, and session errors as a failure.
+* @param events - OpenCode's event stream.
+* @param session - The run's session; other sessions' events are skipped.
+* @param head - Reads the checkout's commit once the agent is done.
+* @param turn - Reads the session's last turn once subscribed, for a turn that ended before.
+* @returns The run's events, ending with `idle` or `fail`.
+*/
+async function* followSession(events, session, head, turn) {
+	let assistant = /* @__PURE__ */ new Set();
+	let replies = /* @__PURE__ */ new Map();
+	let order = [];
+	let busy = Boolean(turn);
+	let idle = async (summary) => ({
+		type: "idle",
+		summary: summary.trim() || "The agent finished without a summary.",
+		head: await head()
+	});
+	for await (let event of events) {
+		if (event.type === "bud.subscribed") {
+			let last = await turn?.();
+			if (last?.state === "done") return yield await idle(last.summary);
+			if (last?.state === "failed") return yield {
+				type: "fail",
+				message: `The agent failed: ${last.message}`,
+				retryable: last.retryable
+			};
+			continue;
+		}
+		let properties = record$1(event.properties);
+		if (properties.sessionID !== session) continue;
+		if (event.type === "message.updated") {
+			let info = record$1(properties.info);
+			if (info.role === "assistant" && typeof info.id === "string") assistant.add(info.id);
+		} else if (event.type === "message.part.updated") {
+			let part = record$1(properties.part);
+			let state = record$1(part.state);
+			if (part.type === "tool" && state.status === "completed") yield {
+				type: "activity",
+				entry: {
+					kind: "tool",
+					text: `${String(part.tool)}${typeof state.title === "string" && state.title ? `: ${state.title}` : ""}`
+				}
+			};
+			else if (part.type === "text" && typeof part.text === "string" && typeof part.messageID === "string") {
+				if (!replies.has(part.messageID)) order.push(part.messageID);
+				replies.set(part.messageID, part.text);
+			}
+		} else if (event.type === "session.status") busy = record$1(properties.status).type === "busy" || busy;
+		else if (event.type === "session.error") {
+			let error = record$1(properties.error);
+			let data = record$1(error.data);
+			yield {
+				type: "fail",
+				message: `The agent failed: ${typeof data.message === "string" ? data.message : String(error.name ?? "The agent failed.")}`,
+				retryable: data.isRetryable === true
+			};
+			return;
+		} else if (event.type === "session.idle" && busy) {
+			let last = order.findLast((id) => assistant.has(id));
+			yield await idle(last ? replies.get(last) ?? "" : "");
+			return;
+		}
+	}
+}
+/**
+* OpenCode as the factory's agent: `opencode serve` in the sandbox, with a password Bud derives
+* per run, and OpenCode's events followed to the agent's summary.
+* @param options - The model as OpenCode names it, `provider/model`, and the server variables
+*   its key is in.
+* @returns The harness.
+*/
+function opencodeHarness(options) {
+	let model = opencodeModel(options.model);
+	return {
+		id: "opencode",
+		model: options.model,
+		keys: options.keys ?? [],
+		port: 4096,
+		start: ({ port, password, tools }) => ({
+			command: `opencode serve --port ${port} --hostname 127.0.0.1`,
+			env: {
+				OPENCODE_SERVER_PASSWORD: password,
+				OPENCODE_CONFIG_CONTENT: opencodeConfig(options.model, tools)
+			}
+		}),
+		attach: ({ port, password, session }) => ({
+			command: `opencode attach http://127.0.0.1:${port} --session '${session.replaceAll("'", "")}'`,
+			env: { OPENCODE_SERVER_PASSWORD: password }
+		}),
+		connect: (address, request) => {
+			let client = opencodeClient({
+				...address,
+				fetch: request
+			});
+			return {
+				healthy: () => client.healthy(),
+				session: (title) => client.session(title),
+				prompt: (session, text, images) => client.prompt(session, model, text, images),
+				follow: (session, head, signal) => followSession(client.events(signal), session, head, () => client.turn(session))
+			};
+		}
+	};
+}
+//#endregion
+//#region app/server/factory-runs.ts
+/** The project's factory runs: what Start task, Approve and the rest do. */
+var FactoryRuns = class extends Service()("@bud.sh/app/FactoryRuns") {};
+succeed$1(RunExecutor, null);
+var unavailable = /* @__PURE__ */ new WeakMap();
+/**
+* What the preview proxy in each sandbox adds to the project's pages: Bud's page bridge, and its
+* DOM picker where the project serves none, so Agent view follows and picks in any project.
+*/
+var previewPage = {
+	bridge: bridgeScript,
+	picker: pickerModule("bud:dom", null),
+	pickerPath: PICKER_MODULE_URL
+};
+var origins = /* @__PURE__ */ new WeakMap();
+/**
+* Remembers where this Bud listens, so agents in sandboxes on this machine reach its task
+* database.
+* @param project - The connected project.
+* @param origin - Such as `http://127.0.0.1:4321`.
+*/
+function rememberOrigin(project, origin) {
+	origins.set(project, origin);
+}
+function agentSecret(root) {
+	return tryPromise({
+		try: async () => {
+			let directory = join(root, "node_modules/.cache/bud");
+			let file = join(directory, "factory-secret");
+			let existing = (await readFile(file, "utf8").catch(() => "")).trim();
+			if (/^[0-9a-f]{64}$/.test(existing)) return existing;
+			let secret = randomBytes(32).toString("hex");
+			await mkdir(directory, { recursive: true });
+			await writeFile(file, `${secret}\n`, { mode: 384 });
+			return secret;
+		},
+		catch: (cause) => new AdapterStartupError({
+			message: "Could not keep the factory’s agent secret.",
+			cause
+		})
+	});
+}
+/**
+* Carries out runs in the sandboxes the project's sandbox plugin makes, with its harness's agent.
+* @param project - The connected project and its factory config.
+* @returns The executor; null when the factory or its sandbox is off, or can't run here.
+*/
+function runExecutorLayer(project) {
+	return effect(RunExecutor, gen(function* () {
+		let factory = project.config.factory;
+		let selected = factory?.sandbox;
+		if (!factory || !selected) return null;
+		let credential = factory.push.credential;
+		let pushToken = credential ? process.env[credential] ?? null : null;
+		let keys = Object.fromEntries(factory.agent.keys.flatMap((name) => {
+			let value = process.env[name];
+			return value ? [[name, value]] : [];
+		}));
+		let plugins = configPlugins(project.config);
+		let plugin = plugins.find((candidate) => candidate.name === selected);
+		if (!plugin?.sandbox) return null;
+		let harness = plugins.find((candidate) => candidate.name === factory.agent.harness)?.harness ?? opencodeHarness(factory.agent);
+		let remote = yield* gen(function* () {
+			return yield* (yield* (yield* Git).discover(project.root)).remoteUrl(factory.push.remote);
+		}).pipe(orElseSucceed(() => null));
+		let https = remote ? yield* try_(() => httpsRemote(remote)).pipe(orElseSucceed(() => null)) : null;
+		let sandbox = yield* try_(() => {
+			let made = plugin.sandbox({
+				root: project.root,
+				env: process.env,
+				repository: https,
+				clone: pushToken ? {
+					username: factory.push.username,
+					token: pushToken
+				} : null,
+				withhold: credential ? [credential] : []
+			});
+			if (!made || typeof made !== "object" || typeof made.id !== "string" || [
+				"create",
+				"status",
+				"exec",
+				"spawn",
+				"expose",
+				"stop",
+				"resume",
+				"destroy"
+			].some((name) => typeof made[name] !== "function")) throw new Error(`The plugin ${plugin.name} didn’t make a sandbox adapter.`);
+			return made;
+		}).pipe(tapError(({ cause }) => sync(() => unavailable.set(project, cause instanceof Error ? cause.message : String(cause)))), orElseSucceed(() => null));
+		if (!sandbox) return null;
+		let repository = https ?? project.root;
+		let file = factory.instructions ? join(project.root, factory.instructions) : null;
+		return sandboxExecutor({
+			sandbox,
+			harness,
+			page: previewPage,
+			tools: () => {
+				let origin = sandbox.capabilities.localhost ? origins.get(project) : void 0;
+				return origin ? `${origin}${routes.agentApi.tasks.href()}` : null;
+			},
+			repository,
+			factory,
+			env: keys,
+			secrets: Object.keys(keys),
+			secret: yield* agentSecret(project.root),
+			pushToken,
+			instructions: file ? promise(() => readFile(file, "utf8").catch(() => null)) : void 0
+		});
+	}));
+}
+var MAIN_TRACKING = "refs/bud/factory/main";
+var MERGE_CHECK = 6e4;
+/**
+* The project's runs on its task store, picking up runs left going before a restart. Pushed
+* branches are pictured on the canvas, and a run counts as merged once main contains it.
+* @param project - The connected project and its factory config.
+* @param options - How to tell a merge, and how often to check for one.
+* @returns The runs service; its background work stops with the companion.
+*/
+function factoryRunsLayer(project, options = {}) {
+	return effect(FactoryRuns, gen(function* () {
+		let factory = project.config.factory;
+		let { work } = yield* AdapterRegistry;
+		if (!factory) return noRuns("The factory is off; turn it on with factory in bud.config.ts.");
+		if (!work) return noRuns("Task storage is off, so the factory has nowhere to keep runs.");
+		let activity = yield* StoreActivity;
+		let executor = yield* RunExecutor;
+		let branches = getOrNull(yield* serviceOption(BranchPreviews));
+		let git = getOrNull(yield* serviceOption(Git));
+		let attachments = getOrNull(yield* serviceOption(Attachments));
+		let images = (taskId) => gen(function* () {
+			if (!attachments || !work.readItemData) return [];
+			let { value } = yield* work.readItemData(project.root, taskId, "budContext");
+			let context = parseTaskContext(value);
+			if (!context?.image) return [];
+			let bytes = yield* attachments.get(context.image);
+			if (!bytes) return [];
+			return [{
+				mime: "image/jpeg",
+				name: "comment.jpg",
+				data: Buffer.from(bytes).toString("base64")
+			}];
+		}).pipe(orElseSucceed(() => []));
+		let picture = (change) => (run) => branches ? asVoid(branches[change](run.branch)) : void_$1;
+		let runs = yield* makeRuns({
+			root: project.root,
+			factory,
+			work,
+			executor,
+			unavailable: unavailable.get(project),
+			images,
+			sleepAfterMs: factory.sleepAfter ? factory.sleepAfter * 6e4 : null,
+			changed: activity.notify("work"),
+			onPushed: picture("activate"),
+			onMerged: picture("deactivate")
+		});
+		yield* forkScoped(ignore(runs.resume));
+		let merged = options.merged;
+		if (!merged && git) {
+			let main = project.config.branches.main ?? "main";
+			let { remote } = factory.push;
+			let local = git;
+			let fetched = 0;
+			merged = (commit) => gen(function* () {
+				let repository = yield* local.discover(project.root);
+				if (Date.now() - fetched > 3e4) {
+					fetched = Date.now();
+					yield* ignore(repository.fetchRef(remote, `refs/heads/${main}`, MAIN_TRACKING));
+				}
+				for (let ref of [MAIN_TRACKING, `refs/heads/${main}`]) {
+					let head = yield* orElseSucceed(repository.resolve(ref), () => null);
+					if (!head) continue;
+					if ((yield* orElseSucceed(repository.mergeBase(commit, head), () => null)) === commit) return true;
+				}
+				return false;
+			}).pipe(orElseSucceed(() => false));
+		}
+		if (executor && merged) {
+			let check = merged;
+			yield* runs.checkMerged(check).pipe(ignore, andThen(sleep(`${options.mergeCheckMs ?? MERGE_CHECK} millis`)), forever, forkScoped);
+		}
+		return runs;
+	}));
+}
+//#endregion
 //#region ../files/src/server/errors.ts
 /** A request named an invalid path, or the service was given invalid options. */
 var FilesInputError = class extends TaggedError("FilesInputError") {};
@@ -2352,8 +3080,8 @@ function makeFilesLayer(options, openReader) {
 		let confinement = yield* makeConfinement(config.root);
 		let scanner = yield* makeScanner(confinement, config.limits);
 		let scope$1 = yield* scope;
-		let mutex = yield* make$3(1);
-		let readers = yield* make$3(config.limits.maxConcurrentReads);
+		let mutex = yield* make$2(1);
+		let readers = yield* make$2(config.limits.maxConcurrentReads);
 		let publications = yield* sliding({
 			capacity: 1,
 			replay: 1
@@ -2420,7 +3148,7 @@ function makeFilesLayer(options, openReader) {
 				watcherFault = false;
 				for (let [relative, directory] of wanted) {
 					if (watchers.has(relative)) continue;
-					let ready = yield* make$4();
+					let ready = yield* make$3();
 					let state = { active: false };
 					let stream = confinement.fs.watch(directory.absolute, {
 						recursive: config.recursive,
@@ -2626,7 +3354,7 @@ var FileSearch = class extends Service()("@bud.sh/files/FileSearch") {};
 */
 function fileSearchLayer(options = {}) {
 	return effect(FileSearch, gen(function* () {
-		let files = yield* Files, mutex = yield* make$3(1);
+		let files = yield* Files, mutex = yield* make$2(1);
 		let maxFiles = options.maxFiles ?? 500, maxBytes = options.maxBytes ?? 16777216, timeoutMs = options.timeoutMs ?? 5e3;
 		if (![
 			maxFiles,
@@ -3906,7 +4634,7 @@ function makeMutationSnapshot(confinement, io, openReader, limits) {
 //#region ../files/src/server/write-lock.ts
 /** One companion's explicit workspace writes share this gate; reads and watchers do not. */
 var FileWriteLock = class extends Service()("@bud.sh/files/FileWriteLock") {};
-var fileWriteLockLayer = effect(FileWriteLock, make$3(1));
+var fileWriteLockLayer = effect(FileWriteLock, make$2(1));
 //#endregion
 //#region ../files/src/server/mutations.ts
 /** Plans and applies file actions, and lists the recoveries they kept. */
@@ -4028,7 +4756,7 @@ function makeFileMutationsLayer(options, io, openReader) {
 		let rootInfo = yield* io.inspect(confinement.root, "");
 		let project = hash(`${confinement.root}\0${rootInfo.identity}`);
 		let snapshot = makeMutationSnapshot(confinement, io, openReader, config.limits);
-		let mutex = yield* make$3(1);
+		let mutex = yield* make$2(1);
 		let plans = /* @__PURE__ */ new Map();
 		let store;
 		function recoveryStore() {
@@ -5477,4 +6205,4 @@ function fileReviewActionsLayer(options) {
 	}).pipe(mapError(reviewActionFailure)));
 }
 //#endregion
-export { adapterRegistryLayer as A, sharedModules as B, selected as C, publishChanges as D, liveChannelLayer as E, WorkAdapter as F, make as H, WorkError as I, ScreenModules as L, memoryAdapterLayer as M, parseThreadImport as N, AdapterRegistry as O, ThreadAdapter as P, bundledScreensLayer as R, ready as S, LiveChannel as T, taskDesignModuleId as V, storeActivityLayer as _, FileMutations as a, read as b, FileReview as c, fileSearchLayer as d, Files as f, StoreActivity as g, ReviewActionError as h, fileSavesLayer as i, defineAdapter as j, adapterModuleLoaderLayer as k, fileReviewLayer as l, FilesInputError as m, fileReviewActionsLayer as n, fileMutationsLayer as o, filesLayer as p, FileSaves as r, fileWriteLockLayer as s, FileReviewActions as t, FileSearch as u, storeLiveLayer as v, validate as w, readWorkspace as x, inspect$1 as y, sourceScreensLayer as z };
+export { liveChannelLayer as A, ThreadAdapter as B, inspect$1 as C, selected as D, ready as E, AdapterRegistry as F, sourceScreensLayer as G, WorkError as H, AdapterStartupError as I, make as J, sharedModules as K, adapterRegistryLayer as L, Attachments as M, attachmentsLayer as N, validate as O, directoryAttachmentStore as P, defineAdapter as R, storeLiveLayer as S, readWorkspace as T, ScreenModules as U, WorkAdapter as V, bundledScreensLayer as W, factoryRunsLayer as _, FileMutations as a, StoreActivity as b, FileReview as c, fileSearchLayer as d, Files as f, FactoryRuns as g, ReviewActionError as h, fileSavesLayer as i, publishChanges as j, LiveChannel as k, fileReviewLayer as l, FilesInputError as m, fileReviewActionsLayer as n, fileMutationsLayer as o, filesLayer as p, taskDesignModuleId as q, FileSaves as r, fileWriteLockLayer as s, FileReviewActions as t, FileSearch as u, rememberOrigin as v, read as w, storeActivityLayer as x, runExecutorLayer as y, parseThreadImport as z };