@kky42/pievo-server 3.0.0 → 4.1.0

package/.output/server/_ssr/{boot-CYRi-wez.mjs → boot-DmpKtb0A.mjs}

@@ -11,114 +11,117 @@ import { fileURLToPath } from "node:url";
 import path from "node:path";
 import os from "node:os";
 import fs$1 from "node:fs/promises";
-//#region node_modules/.nitro/vite/services/ssr/assets/loopTags-C6vATFCp.js
-var loopTags_C6vATFCp_exports = /* @__PURE__ */ __exportAll$1({
-	$: () => lastRun,
-	A: () => buildLoopManifest,
-	At: () => runningRunForLoop,
-	B: () => forceDeleteLoop,
-	Bt: () => upsertConfiguredArtifactFile,
-	C: () => acknowledgeRetiredReport,
-	Ct: () => recordRunReportOnce,
-	D: () => blobExists,
-	Dt: () => repairTerminalRunLeases,
-	E: () => artifactFileReferencesHash,
-	Et: () => releaseAbsentReconciliations,
-	F: () => createMachine,
-	Ft: () => stopLoop,
-	G: () => getMachine,
-	Gt: () => CODING_AGENTS,
-	H: () => getArtifactFile,
-	Ht: () => db,
-	I: () => deleteBlob,
-	It: () => store_exports,
-	J: () => getRunSnapshot,
-	Jt: () => logger_exports,
-	K: () => getReportReceipt,
-	Kt: () => coerceCodingAgent,
-	L: () => enqueueRun,
-	Lt: () => tryDeleteLoop,
-	M: () => countRunSnapshots,
-	Mt: () => setMachineOnline,
-	N: () => countRuns,
-	Nt: () => snapshotBlobRefs,
-	O: () => blobHashesOlderThan,
-	Ot: () => requestDeleteLoop,
-	P: () => createLoop,
-	Pt: () => startLoop,
-	Q: () => initializeCronCadence,
-	Qt: () => __exportAll,
-	R: () => expirePendingRun,
-	Rt: () => updateLoop,
-	S: () => sha256Buf,
-	St: () => recordBlob,
-	T: () => advanceDueSchedules,
-	Tt: () => rejectTerminalReport,
-	U: () => getExactTerminalReportIncident,
-	Ut: () => runMigrations,
-	V: () => forceDeleteMachine,
-	Vt: () => closeClient,
-	W: () => getLoop,
-	Wt: () => runs,
-	X: () => hasPendingRun,
-	Xt: () => GC_INTERVAL_MS,
-	Y: () => getTerminalReportIncidents,
-	Yt: () => BLOB_GC_GRACE_MS,
-	Z: () => hasRunningRun,
-	Zt: () => dataDir,
-	_: () => BLOB_CAP,
-	_t: () => recentLoopUsage,
+//#region node_modules/.nitro/vite/services/ssr/assets/loopTags-CnVLi70h.js
+var loopTags_CnVLi70h_exports = /* @__PURE__ */ __exportAll$1({
+	$: () => loopIdsWithSnapshots,
+	$t: () => BLOB_GC_GRACE_MS,
+	A: () => enqueueRun,
+	At: () => updateMachine,
+	B: () => getRun,
+	Bt: () => loopFileNames,
+	C: () => buildLoopManifest,
+	Ct: () => setMachineOnline,
+	D: () => createLoop,
+	Dt: () => store_exports,
+	E: () => countRuns,
+	Et: () => stopLoop,
+	F: () => getArtifactFile,
+	Ft: () => MEMORY_CHAR_CAP,
+	G: () => initializeCronCadence,
+	Gt: () => closeClient,
+	H: () => getTerminalReportIncidents,
+	Ht: () => sha256Buf,
+	I: () => getExactTerminalReportIncident,
+	It: () => MEMORY_FILE,
+	J: () => listLoops,
+	Jt: () => runs,
+	K: () => lastRun,
+	Kt: () => db,
+	L: () => getLoop,
+	Lt: () => fileLimitLabel,
+	M: () => finalizeRunningRun,
+	Mt: () => EMPTY_SHA256,
+	N: () => forceDeleteLoop,
+	Nt: () => LOOP_FILE_BYTE_CAP,
+	O: () => createMachine,
+	Ot: () => tryDeleteLoop,
+	P: () => forceDeleteMachine,
+	Pt: () => LoopFiles,
+	Q: () => liveBlobRefs,
+	Qt: () => logger_exports,
+	R: () => getMachine,
+	Rt: () => isValidHash,
+	S: () => blobSizes,
+	St: () => runningRunsForMachine,
+	T: () => countRunSnapshots,
+	Tt: () => startLoop,
+	U: () => hasPendingRun,
+	Ut: () => validArtifactName,
+	V: () => getRunSnapshot,
+	Vt: () => loopFiles_exports,
+	W: () => hasRunningRun,
+	Wt: () => createBlobStore,
+	X: () => listRuns,
+	Xt: () => coerceCodingAgent,
+	Y: () => listMachines,
+	Yt: () => CODING_AGENTS,
+	Z: () => listRunsBefore,
+	Zt: () => logger,
+	_: () => acknowledgeRetiredReport,
+	_t: () => releaseAbsentReconciliations,
 	a: () => TERMINAL_GRACE_MS,
-	at: () => liveBlobRefs,
-	b: () => parseArtifactSyncBody,
-	bt: () => reconcileReclaimedRun,
+	at: () => previousRunFileNotices,
+	b: () => artifactFileReferencesHash,
+	bt: () => requestRunCancel,
 	c: () => machineIdFromToken,
-	ct: () => machineReferencesBlob,
+	ct: () => putRunSnapshot,
 	d: () => readNewIdempotency,
-	dt: () => pauseLoopState,
-	et: () => listArtifacts,
+	dt: () => reclaimRun,
+	en: () => GC_INTERVAL_MS,
+	et: () => loopsForMachine,
 	f: () => recordNewIdempotency,
-	ft: () => prevRunSnapshot,
+	ft: () => reconcileReclaimedRun,
 	g: () => tokens_exports,
-	gt: () => putTerminalReportIncidentIfAbsent,
+	gt: () => rejectTerminalReport,
 	h: () => sha256,
-	ht: () => putRunSnapshot,
+	ht: () => refreshRunHeartbeats,
 	i: () => machinePresence,
-	it: () => listRunsBefore,
-	j: () => claimReadyRunForMachine,
-	jt: () => runningRunsForMachine,
-	k: () => blobSizes,
-	kt: () => requestRunCancel,
+	it: () => prevRunSnapshot,
+	j: () => expirePendingRun,
+	jt: () => writeLoopFile,
+	k: () => deleteBlob,
+	kt: () => updateLoop,
 	l: () => mintDeviceToken,
-	lt: () => openRuns,
+	lt: () => putTerminalReportIncidentIfAbsent,
 	m: () => retireLease,
-	mt: () => putReportReceiptIfAbsent,
+	mt: () => recordBlob,
 	n: () => isOutdated,
-	nt: () => listMachines,
+	nt: () => pauseLoop,
 	o: () => connectKeyValid,
-	ot: () => loopIdsWithSnapshots,
+	ot: () => pruneRunSnapshots,
 	p: () => resolveLease,
-	pt: () => pruneRunSnapshots,
-	q: () => getRun,
-	qt: () => logger,
+	pt: () => reconciliationStatesForRuns,
+	q: () => listArtifacts,
+	qt: () => runMigrations,
 	r: () => isValidSemver,
-	rt: () => listRuns,
+	rt: () => pauseLoopState,
 	s: () => isDeviceTokenShape,
-	st: () => loopsForMachine,
+	st: () => putReportReceiptIfAbsent,
 	t: () => validateLoopTags,
-	tt: () => listLoops,
+	tn: () => __exportAll,
+	tt: () => openRuns,
 	u: () => pruneExpiredLeases,
-	ut: () => pauseLoop,
-	v: () => artifacts_exports,
-	vt: () => reclaimRun,
-	w: () => acknowledgeRetiredTerminalIncident,
-	wt: () => refreshRunHeartbeats,
-	x: () => safeRelPath,
-	xt: () => reconciliationStatesForRuns,
-	y: () => isValidHash,
-	yt: () => reconcileConfiguredArtifacts,
-	z: () => finalizeRunningRun,
-	zt: () => updateMachine
+	ut: () => recentLoopUsage,
+	v: () => acknowledgeRetiredTerminalIncident,
+	vt: () => repairTerminalRunLeases,
+	w: () => claimReadyRunForMachine,
+	wt: () => snapshotBlobRefs,
+	x: () => blobHashesOlderThan,
+	xt: () => runningRunForLoop,
+	y: () => advanceDueSchedules,
+	yt: () => requestDeleteLoop,
+	z: () => getReportReceipt,
+	zt: () => loopFileIssue
 });
 var import_pino = /* @__PURE__ */ __toESM(require_pino());
 var import_pino_pretty = /* @__PURE__ */ __toESM(require_pino_pretty());
@@ -133,7 +136,7 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 /**
-* Server data directory: the embedded database (`pgdata/`), artifact bytes
+* Server data directory: the embedded database (`pgdata/`), loop-file bytes
 * (`blobs/`), and the launcher's pid/lock/log files. Kept apart from the
 * daemon's `~/.pievo` so a device running both never mixes their state.
 * Override with `PIEVO_DATA_DIR` (absolute; `~` is not expanded).
@@ -228,7 +231,8 @@ var loops = pgTable("loops", {
 	statusKeep: text("status_keep").notNull(),
 	statusNoChange: text("status_no_change").notNull(),
 	statusBlock: text("status_block").notNull(),
-	/** Exact workdir-relative artifact paths collected by the daemon after provider exit. */
+	/** Configured artifact file names (`.md`/`.html`), in addition to the
+	*  always-present MEMORY.md. See `gateway/loopFiles.ts`. */
 	artifacts: jsonb("artifacts").$type().notNull().default([]),
 	cron: text("cron").notNull(),
 	scheduleMode: text("schedule_mode", { enum: ["cron", "continuous"] }).notNull(),
@@ -308,7 +312,11 @@ var runs = pgTable("runs", {
 		mode: "string"
 	}),
 	heartbeatAt: text("heartbeat_at"),
-	reportIncident: jsonb("report_incident").$type()
+	reportIncident: jsonb("report_incident").$type(),
+	/** Loop-file versions this run produced but that were not kept (over limit,
+	*  owner edited during the run, upload lost). Shown on the run and repeated in
+	*  the next run's prompt so the agent can correct course. */
+	fileNotices: jsonb("file_notices").$type()
 }, (t) => [
 	index("runs_loop_idx").on(t.loopId),
 	index("runs_phase_idx").on(t.phase),
@@ -387,21 +395,23 @@ var blobs = pgTable("blobs", {
 	createdAt: text("created_at").notNull()
 });
 /**
-* The current configured file set of each loop — one row per live or tombstoned
-* relative path. `hash` → `blobs.hash`; null when the file is deleted or oversize
-* (metadata-only, no bytes synced). The
-* unique (loopId, path) index is the upsert key the sync reconciliation drives.
+* The current file set of each loop — one row per live or tombstoned name.
+* `hash` → `blobs.hash`; null for a tombstoned (deleted or unconfigured) file.
+* The unique (loopId, path) index is the upsert key owner writes and run
+* finalization share.
 */
 var artifactFiles = pgTable("artifact_files", {
 	id: text("id").primaryKey(),
 	loopId: text("loop_id").notNull(),
-	/** Normalized workdir-relative path (never absolute or escaping the workdir). */
+	/** Loop file name: MEMORY.md or a configured artifact name. */
 	path: text("path").notNull(),
 	hash: text("hash"),
 	size: integer("size"),
-	/** Bytes contain a NUL (set even for oversize metadata-only files). */
+	/** Legacy snapshot/diff metadata. Loop-file ingress rejects NUL, so new rows
+	*  always store false. */
 	binary: boolean("binary").notNull().default(false),
-	/** File exceeds the per-file byte cap → metadata-only (path + size), no blob. */
+	/** Legacy snapshot/diff metadata. Loop-file ingress rejects over-limit versions,
+	*  so new rows always store false. */
 	oversize: boolean("oversize").notNull().default(false),
 	deleted: boolean("deleted").notNull().default(false),
 	updatedAt: text("updated_at").notNull()
@@ -411,7 +421,7 @@ var artifactFiles = pgTable("artifact_files", {
 	index("artifact_files_hash_idx").on(t.hash)
 ]);
 /**
-* The loop's full artifact manifest captured at each run's finalize — the input
+* The loop's full loop-file manifest captured at each run's finalize — the input
 * to the per-run diff. Written cheaply on report (no diff computed on write);
 * `getRunDiff` lazily compares run N's snapshot with the preceding snapshot.
 * One row per run (runId primary key).
@@ -496,6 +506,222 @@ async function closeClient() {
 	} catch {}
 }
 /**
+* Content-addressed blob byte store for loop files.
+*
+* Bytes are keyed by their sha256 hash (content-addressed ⇒ deduped across every
+* loop/run). The store ONLY writes/reads bytes — it never executes or interprets
+* them — preserving the server's zero-exec invariant.
+*
+* `LocalBlobStore` is the durable store under `<dataDir>/blobs`;
+* `MemoryBlobStore` is the injected test fake.
+*/
+var log$3 = logger.child({ mod: "blobstore" });
+var SHA256_HEX = /^[a-f0-9]{64}$/;
+/** Durable filesystem adapter. Hash sharding bounds entries per directory; atomic
+* temp-file renames ensure readers see either complete bytes or no object. */
+var LocalBlobStore = class {
+	root;
+	initialized;
+	constructor(root = path.join(dataDir(), "blobs")) {
+		this.root = root;
+	}
+	file(hash) {
+		if (!SHA256_HEX.test(hash)) throw new Error("invalid sha256 blob key");
+		return path.join(this.root, hash.slice(0, 2), hash);
+	}
+	async has(hash) {
+		const target = this.file(hash);
+		await this.ensureInitialized();
+		try {
+			return (await fs$1.stat(target)).isFile();
+		} catch (err) {
+			if (err.code === "ENOENT") return false;
+			throw err;
+		}
+	}
+	async syncDir(dir) {
+		let handle;
+		try {
+			handle = await fs$1.open(dir, "r");
+			await handle.sync();
+		} catch (err) {
+			const code = err.code;
+			if (![
+				"EINVAL",
+				"ENOTSUP",
+				"EBADF",
+				"EPERM",
+				"ENOENT"
+			].includes(code)) throw err;
+		} finally {
+			await handle?.close().catch(() => {});
+		}
+	}
+	ensureInitialized() {
+		return this.initialized ??= (async () => {
+			await fs$1.mkdir(this.root, { recursive: true });
+			await this.syncDir(path.dirname(path.dirname(this.root)));
+			await this.syncDir(path.dirname(this.root));
+			await this.syncDir(this.root);
+			for (const shard of await fs$1.readdir(this.root, { withFileTypes: true })) {
+				if (!shard.isDirectory() || !/^[a-f0-9]{2}$/.test(shard.name)) continue;
+				const dir = path.join(this.root, shard.name);
+				let removed = false;
+				for (const name of await fs$1.readdir(dir)) {
+					if (!/^\.[a-f0-9]{64}\.\d+\.[0-9a-f-]+\.tmp$/.test(name)) continue;
+					await fs$1.rm(path.join(dir, name), { force: true });
+					removed = true;
+				}
+				if (removed) await this.syncDir(dir);
+			}
+		})();
+	}
+	async put(hash, bytes) {
+		const target = this.file(hash);
+		await this.ensureInitialized();
+		const dir = path.dirname(target);
+		await fs$1.mkdir(dir, { recursive: true });
+		await this.syncDir(this.root);
+		const temp = path.join(dir, `.${hash}.${process.pid}.${randomUUID()}.tmp`);
+		let handle;
+		try {
+			handle = await fs$1.open(temp, "wx", 384);
+			await handle.writeFile(bytes);
+			await handle.sync();
+			await handle.close();
+			handle = void 0;
+			try {
+				await fs$1.rename(temp, target);
+				await this.syncDir(dir);
+			} catch (err) {
+				if ([
+					"EEXIST",
+					"EACCES",
+					"EPERM"
+				].includes(err.code ?? "") && await this.has(hash)) {
+					await fs$1.rm(temp, { force: true });
+					return;
+				}
+				throw err;
+			}
+		} catch (err) {
+			await handle?.close().catch(() => {});
+			await fs$1.rm(temp, { force: true }).catch(() => {});
+			throw err;
+		}
+	}
+	async get(hash) {
+		const target = this.file(hash);
+		await this.ensureInitialized();
+		try {
+			return await fs$1.readFile(target);
+		} catch (err) {
+			if (err.code === "ENOENT") return null;
+			throw err;
+		}
+	}
+	async delete(hash) {
+		const target = this.file(hash);
+		await this.ensureInitialized();
+		await fs$1.rm(target, { force: true });
+		await this.syncDir(path.dirname(target));
+	}
+};
+/** The one local blob store shared by loop-file writes/reads and GC. */
+function createBlobStore() {
+	const local = new LocalBlobStore();
+	log$3.info({ root: local.root }, "blob store: local filesystem");
+	return local;
+}
+/**
+* Loop files: a loop's server-owned memory and display artifacts.
+*
+* Every loop has the required `MEMORY.md` plus up to MAX_ARTIFACTS configured
+* `.md`/`.html` artifact names. The server is authoritative: bytes live in the
+* content-addressed BlobStore and the current version of each name is an
+* `artifact_files` row. For each run the daemon downloads the current files into
+* a private run directory, and the terminal report carries the changed versions
+* back with the hash each edit started from, so an owner edit made during the run
+* wins over the agent's (base-hash check under the loop lock).
+*
+* Limits are part of the agent-facing prompt contract and are mirrored in the
+* daemon (`packages/daemon/src/loop-files.ts`); change both together. An over-limit
+* version is rejected and the previous version kept, never truncated, because a cut
+* HTML file renders broken and a cut memory file silently loses its newest notes.
+*/
+var loopFiles_exports = /* @__PURE__ */ __exportAll({
+	ARTIFACT_BYTE_CAP: () => ARTIFACT_BYTE_CAP,
+	EMPTY_SHA256: () => EMPTY_SHA256,
+	LOOP_FILE_BYTE_CAP: () => LOOP_FILE_BYTE_CAP,
+	LoopFiles: () => LoopFiles,
+	MAX_ARTIFACTS: () => 4,
+	MEMORY_CHAR_CAP: () => MEMORY_CHAR_CAP,
+	MEMORY_FILE: () => MEMORY_FILE,
+	fileLimitLabel: () => fileLimitLabel,
+	isValidHash: () => isValidHash,
+	loopFileIssue: () => loopFileIssue,
+	loopFileNames: () => loopFileNames,
+	sha256Buf: () => sha256Buf,
+	validArtifactName: () => validArtifactName
+});
+var MEMORY_FILE = "MEMORY.md";
+/** Memory is re-read by every run, so it is bounded in characters (Unicode code
+*  points), roughly 2k tokens of prompt context per run. */
+var MEMORY_CHAR_CAP = 8e3;
+/** HTML reports are bulky; 2 MB keeps a run's upload and the dashboard iframe cheap. */
+var ARTIFACT_BYTE_CAP = 2 * 1024 * 1024;
+/** sha256 of zero bytes: the version of a loop file that has never been written. */
+var EMPTY_SHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+var ARTIFACT_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}\.(md|html)$/;
+function sha256Buf(bytes) {
+	return createHash("sha256").update(bytes).digest("hex");
+}
+function isValidHash(hash) {
+	return typeof hash === "string" && /^[0-9a-f]{64}$/.test(hash);
+}
+/** A plain file name (no directories) ending in .md or .html, other than MEMORY.md. */
+function validArtifactName(name) {
+	return typeof name === "string" && ARTIFACT_NAME_RE.test(name) && name.toLowerCase() !== "MEMORY.md".toLowerCase();
+}
+function loopFileNames(loop) {
+	return [MEMORY_FILE, ...loop.artifacts];
+}
+function fileLimitLabel(name) {
+	return name === "MEMORY.md" ? `${MEMORY_CHAR_CAP} characters` : "2 MB";
+}
+/** Why `bytes` cannot become the next version of `name`, or undefined if it can. */
+function loopFileIssue(name, bytes) {
+	if (bytes.includes(0)) return `${name}: binary content is not allowed`;
+	if (name === "MEMORY.md") {
+		const chars = Array.from(bytes.toString("utf8")).length;
+		if (chars > 8e3) return `${name}: ${chars} characters exceeds the ${MEMORY_CHAR_CAP}-character limit`;
+		return;
+	}
+	if (bytes.length > 2097152) return `${name}: ${(bytes.length / 1024 / 1024).toFixed(1)} MB exceeds the 2 MB limit`;
+}
+/** The largest byte size any loop file can have (a code point is at most 4 bytes). */
+var LOOP_FILE_BYTE_CAP = Math.max(ARTIFACT_BYTE_CAP, MEMORY_CHAR_CAP * 4);
+var LoopFiles = class {
+	blobStore;
+	constructor(blobStore = createBlobStore()) {
+		this.blobStore = blobStore;
+	}
+	readBlob(hash) {
+		if (!isValidHash(hash)) return Promise.resolve(null);
+		if (hash === "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855") return Promise.resolve(Buffer.alloc(0));
+		return this.blobStore.get(hash);
+	}
+	/** Persist bytes under their own hash. Idempotent; callers record the metadata row. */
+	async putBlob(bytes) {
+		const hash = sha256Buf(bytes);
+		if (hash !== "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" && !await this.blobStore.has(hash)) await this.blobStore.put(hash, bytes);
+		return hash;
+	}
+	async hasBlob(hash) {
+		return hash === "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" || this.blobStore.has(hash);
+	}
+};
+/**
 * Data-access layer over Drizzle. Loop-locked state transitions live here; every
 * DB-touching function is async, while the pure helpers stay sync.
 */
@@ -505,7 +731,6 @@ var store_exports = /* @__PURE__ */ __exportAll({
 	acknowledgeRetiredTerminalIncident: () => acknowledgeRetiredTerminalIncident,
 	advanceDueSchedules: () => advanceDueSchedules,
 	artifactFileReferencesHash: () => artifactFileReferencesHash,
-	blobExists: () => blobExists,
 	blobHashesOlderThan: () => blobHashesOlderThan,
 	blobSizes: () => blobSizes,
 	buildLoopManifest: () => buildLoopManifest,
@@ -540,24 +765,22 @@ var store_exports = /* @__PURE__ */ __exportAll({
 	liveBlobRefs: () => liveBlobRefs,
 	loopIdsWithSnapshots: () => loopIdsWithSnapshots,
 	loopsForMachine: () => loopsForMachine,
-	machineReferencesBlob: () => machineReferencesBlob,
 	newLoopId: () => newLoopId,
 	nextCronAt: () => nextCronAt,
 	openRuns: () => openRuns,
 	pauseLoop: () => pauseLoop,
 	pauseLoopState: () => pauseLoopState,
 	prevRunSnapshot: () => prevRunSnapshot,
+	previousRunFileNotices: () => previousRunFileNotices,
 	pruneRunSnapshots: () => pruneRunSnapshots,
 	putReportReceiptIfAbsent: () => putReportReceiptIfAbsent,
 	putRunSnapshot: () => putRunSnapshot,
 	putTerminalReportIncidentIfAbsent: () => putTerminalReportIncidentIfAbsent,
 	recentLoopUsage: () => recentLoopUsage,
 	reclaimRun: () => reclaimRun,
-	reconcileConfiguredArtifacts: () => reconcileConfiguredArtifacts,
 	reconcileReclaimedRun: () => reconcileReclaimedRun,
 	reconciliationStatesForRuns: () => reconciliationStatesForRuns,
 	recordBlob: () => recordBlob,
-	recordRunReportOnce: () => recordRunReportOnce,
 	refreshRunHeartbeats: () => refreshRunHeartbeats,
 	rejectTerminalReport: () => rejectTerminalReport,
 	releaseAbsentReconciliations: () => releaseAbsentReconciliations,
@@ -574,7 +797,7 @@ var store_exports = /* @__PURE__ */ __exportAll({
 	tryDeleteLoop: () => tryDeleteLoop,
 	updateLoop: () => updateLoop,
 	updateMachine: () => updateMachine,
-	upsertConfiguredArtifactFile: () => upsertConfiguredArtifactFile
+	writeLoopFile: () => writeLoopFile
 });
 function newLoopId() {
 	return `loop-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
@@ -697,7 +920,7 @@ async function updateLoopTx(tx, current, patch, at) {
 	}).where(eq(loops.id, current.id)).returning())[0];
 	if (patch.enabled === false) await cancelPendingTx(tx, and(eq(runs.loopId, current.id), eq(runs.phase, "pending"), eq(runs.requestedBy, "system")), "canceled - loop paused before this system run was claimed", at);
 	if (patch.artifacts !== void 0) {
-		const allowed = new Set(patch.artifacts ?? []);
+		const allowed = new Set([MEMORY_FILE, ...patch.artifacts ?? []]);
 		const removed = (await tx.select({
 			id: artifactFiles.id,
 			path: artifactFiles.path
@@ -1040,26 +1263,32 @@ async function activeRunForReportTx(tx, loopId, runId, leaseTokenHash) {
 		run
 	} : { state: "run-not-running" };
 }
-/** Record the agent-authored status/message exactly once. The loop row is the
-* serialization point, so sequential and concurrent duplicate callbacks both
-* lose before any field can be overwritten. */
-async function recordRunReportOnce(input) {
-	return db.transaction(async (tx) => {
-		if (!(await tx.select({ id: loops.id }).from(loops).where(eq(loops.id, input.loopId)).for("update"))[0]) return { state: "missing-loop" };
-		const active = await activeRunForReportTx(tx, input.loopId, input.runId, input.leaseTokenHash);
-		if (active.state !== "active") return active;
-		if (active.run.status != null || active.run.message != null) return { state: "already-reported" };
-		const at = nowIso$1();
-		const run = (await tx.update(runs).set({
-			status: input.status,
-			message: input.message,
-			updatedAt: at
-		}).where(and(eq(runs.id, input.runId), eq(runs.loopId, input.loopId), eq(runs.phase, "running"), isNull(runs.status), isNull(runs.message))).returning())[0];
-		return run ? {
-			state: "applied",
-			run
-		} : { state: "already-reported" };
-	});
+/** Apply a run's loop-file versions under the loop lock. A file whose current
+* version is no longer the one the run started from was changed by the owner (or a
+* newer run) meanwhile; that version wins and the agent's edit becomes a notice. */
+async function applyLoopFileUpdatesTx(tx, loop, updates, at) {
+	const notices = [];
+	const configured = new Set(loopFileNames(loop));
+	for (const update of updates) {
+		if (!configured.has(update.name)) {
+			notices.push(`${update.name}: no longer configured on this loop; this run's version was discarded`);
+			continue;
+		}
+		const row = (await tx.select().from(artifactFiles).where(and(eq(artifactFiles.loopId, loop.id), eq(artifactFiles.path, update.name))).limit(1).for("update"))[0];
+		if ((row && !row.deleted && row.hash ? row.hash : "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855") !== update.baseHash) {
+			notices.push(`${update.name}: changed outside this run while it was running; that version was kept and this run's edit was discarded`);
+			continue;
+		}
+		await writeConfiguredArtifactTx(tx, {
+			loopId: loop.id,
+			path: update.name,
+			hash: update.hash,
+			size: update.size,
+			binary: false,
+			oversize: false
+		}, at);
+	}
+	return notices;
 }
 async function finalizeTerminalRunTx(tx, input) {
 	if (input.receipt) await lockReportIdTx(tx, input.receipt.reportId);
@@ -1074,8 +1303,10 @@ async function finalizeTerminalRunTx(tx, input) {
 	if (!target) return void 0;
 	const runIndex = await ensureRunIndexTx(tx, target);
 	const at = typeof input.runPatch.ts === "string" ? input.runPatch.ts : nowIso$1();
+	const fileNotices = [...input.runPatch.fileNotices ?? [], ...input.fileUpdates?.length ? await applyLoopFileUpdatesTx(tx, current, input.fileUpdates, at) : []];
 	const run = (await tx.update(runs).set({
 		...input.runPatch,
+		fileNotices: fileNotices.length ? fileNotices : null,
 		runIndex,
 		updatedAt: at
 	}).where(and(eq(runs.id, input.runId), eq(runs.loopId, input.loopId), eq(runs.phase, input.runPhase))).returning())[0];
@@ -1207,12 +1438,13 @@ async function rejectTerminalReport(input) {
 }
 /** Atomically CAS running→terminal and apply the report's loop patch.
 * The loop patch is unreachable when cancel/reclaim/another report won. */
-async function finalizeRunningRun(loopId, runId, runPatch, loopPatch = {}, leaseTokenHash, failureAutopauseStreak = 0, receipt) {
+async function finalizeRunningRun(loopId, runId, runPatch, loopPatch = {}, leaseTokenHash, failureAutopauseStreak = 0, receipt, fileUpdates) {
 	return db.transaction(async (tx) => {
 		return finalizeTerminalRunTx(tx, {
 			loopId,
 			runId,
 			runPhase: "running",
+			fileUpdates,
 			runPatch,
 			loopPatch,
 			leaseTokenHash,
@@ -1271,12 +1503,13 @@ async function releaseAbsentReconciliations(machineId, recoverableRunIds, at = n
 * exactly once. Keeping the lease check/delete beside the run + loop writes closes the
 * error→error double-report hole where a phase CAS alone cannot distinguish the
 * first real failure from a second concurrent one. */
-async function reconcileReclaimedRun(loopId, runId, leaseTokenHash, runPatch, loopPatch = {}, failureAutopauseStreak = 0, receipt) {
+async function reconcileReclaimedRun(loopId, runId, leaseTokenHash, runPatch, loopPatch = {}, failureAutopauseStreak = 0, receipt, fileUpdates) {
 	return db.transaction(async (tx) => {
 		return finalizeTerminalRunTx(tx, {
 			loopId,
 			runId,
 			runPhase: "error",
+			fileUpdates,
 			runPatch,
 			loopPatch,
 			leaseTokenHash,
@@ -1521,9 +1754,6 @@ async function setMachineOnline(id, online) {
 		lastSeen: nowIso$1()
 	}).where(eq(machines.id, id));
 }
-async function blobExists(hash) {
-	return !!(await db.select({ hash: blobs.hash }).from(blobs).where(eq(blobs.hash, hash)))[0];
-}
 /** Verified byte lengths recorded at blob ingress, used to budget reads before
 * touching the byte store. Missing metadata is intentionally not estimated. */
 async function blobSizes(hashes) {
@@ -1541,13 +1771,6 @@ async function recordBlob(hash, size) {
 		createdAt: nowIso$1()
 	}).onConflictDoNothing();
 }
-/** Does any LIVE artifact_files row on a loop bound to `machineId` point at `hash`?
-*  Gates putBlob: a device may only upload bytes the sync handshake actually asked
-*  it for (a row a prior sync wrote for one of ITS loops), never arbitrary
-*  self-hashed blobs — otherwise any device token is an uncapped blob write channel. */
-async function machineReferencesBlob(machineId, hash) {
-	return !!(await db.select({ id: artifactFiles.id }).from(artifactFiles).innerJoin(loops, eq(artifactFiles.loopId, loops.id)).where(and(eq(loops.machineId, machineId), eq(artifactFiles.hash, hash), eq(artifactFiles.deleted, false), sql`${loops.artifacts} @> jsonb_build_array(${artifactFiles.path})`)).limit(1))[0];
-}
 async function writeConfiguredArtifactTx(tx, input, ts) {
 	await tx.insert(artifactFiles).values({
 		id: randomUUID(),
@@ -1571,36 +1794,32 @@ async function writeConfiguredArtifactTx(tx, input, ts) {
 		}
 	});
 }
-/** Upsert only while the exact literal path remains configured, serialized with
-* owner edits by the loop row lock. */
-async function upsertConfiguredArtifactFile(input) {
+/** Owner replacement of one loop file. Serialized with run finalization by the
+* loop lock, so a run that started from the previous version cannot overwrite it. */
+async function writeLoopFile(loopId, name, hash, size) {
 	return db.transaction(async (tx) => {
-		const loop = (await tx.select({ artifacts: loops.artifacts }).from(loops).where(eq(loops.id, input.loopId)).for("update"))[0];
-		if (!loop || !loop.artifacts.includes(input.path)) return false;
-		await writeConfiguredArtifactTx(tx, input, nowIso$1());
+		const loop = (await tx.select().from(loops).where(eq(loops.id, loopId)).for("update"))[0];
+		if (!loop || !loopFileNames(loop).includes(name)) return false;
+		await writeConfiguredArtifactTx(tx, {
+			loopId,
+			path: name,
+			hash,
+			size,
+			binary: false,
+			oversize: false
+		}, nowIso$1());
 		return true;
 	});
 }
-/** Reconcile deletions against both the request's starting allowlist and the
-* current locked loop config. Newly-added paths are never tombstoned by an older
-* in-flight manifest; removed paths can never remain live. */
-async function reconcileConfiguredArtifacts(loopId, configuredAtStart, keepPaths) {
-	return db.transaction(async (tx) => {
-		const loop = (await tx.select({ artifacts: loops.artifacts }).from(loops).where(eq(loops.id, loopId)).for("update"))[0];
-		if (!loop) return 0;
-		const current = new Set(loop.artifacts);
-		const started = new Set(configuredAtStart);
-		const keep = new Set(keepPaths);
-		const stale = (await tx.select().from(artifactFiles).where(and(eq(artifactFiles.loopId, loopId), eq(artifactFiles.deleted, false)))).filter((file) => !current.has(file.path) || started.has(file.path) && !keep.has(file.path));
-		if (!stale.length) return 0;
-		const at = nowIso$1();
-		await tx.update(artifactFiles).set({
-			hash: null,
-			deleted: true,
-			updatedAt: at
-		}).where(inArray(artifactFiles.id, stale.map((file) => file.id)));
-		return stale.length;
-	});
+/** File notices of the immediately previous terminal run, for the next prompt.
+*  Canceled runs are terminal too: their notices (edits discarded) are repeated,
+*  and an older run's notice must not masquerade as the previous run's. */
+async function previousRunFileNotices(loopId, beforeRunIndex) {
+	return (await db.select({ fileNotices: runs.fileNotices }).from(runs).where(and(eq(runs.loopId, loopId), isNotNull(runs.runIndex), lt(runs.runIndex, beforeRunIndex), inArray(runs.phase, [
+		"done",
+		"error",
+		"canceled"
+	]))).orderBy(desc(runs.runIndex)).limit(1))[0]?.fileNotices ?? [];
 }
 async function listArtifacts(loopId) {
 	return db.select().from(artifactFiles).where(and(eq(artifactFiles.loopId, loopId), eq(artifactFiles.deleted, false))).orderBy(artifactFiles.path);
@@ -1618,8 +1837,8 @@ async function buildLoopManifest(loopId) {
 	};
 	return manifest;
 }
-/** Write/overwrite a run's snapshot (path → file metadata). Idempotent on runId
-*  so a re-report of the same run just refreshes the captured artifact state. */
+/** Write/overwrite a run's snapshot (name → file metadata). Idempotent on runId
+*  so a re-report of the same run just refreshes the captured loop-file state. */
 async function putRunSnapshot(runId, loopId, manifest) {
 	await db.insert(runSnapshots).values({
 		runId,
@@ -1708,89 +1927,6 @@ async function countRunSnapshots() {
 	const r = (await db.select({ n: sql`count(*)` }).from(runSnapshots))[0];
 	return Number(r?.n ?? 0);
 }
-var artifacts_exports = /* @__PURE__ */ __exportAll({
-	BLOB_CAP: () => BLOB_CAP,
-	SYNC_BODY_CAP: () => SYNC_BODY_CAP,
-	isValidHash: () => isValidHash,
-	parseArtifactSyncBody: () => parseArtifactSyncBody,
-	safeRelPath: () => safeRelPath,
-	sha256Buf: () => sha256Buf
-});
-/** Per-file byte cap. At or under ⇒ bytes sync; over ⇒ metadata-only (no bytes). */
-var BLOB_CAP = 10 * 1024 * 1024;
-/** Hard ceiling on the exact-manifest sync POST body. */
-var SYNC_BODY_CAP = 32 * 1024 * 1024;
-var SYNC_FIELDS = new Set(["loopId", "manifest"]);
-var MANIFEST_FIELDS = new Set([
-	"path",
-	"hash",
-	"size",
-	"binary",
-	"oversize"
-]);
-var MAX_STORED_SIZE = 2147483647;
-function exactRecord(value, fields) {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
-	const proto = Object.getPrototypeOf(value);
-	if (proto !== Object.prototype && proto !== null) return false;
-	const keys = Object.keys(value);
-	return keys.length === fields.size && keys.every((key) => fields.has(key));
-}
-function sha256Buf(bytes) {
-	return createHash("sha256").update(bytes).digest("hex");
-}
-function isValidHash(hash) {
-	return typeof hash === "string" && /^[0-9a-f]{64}$/.test(hash);
-}
-/**
-* Validate and preserve an untrusted, loop-folder-relative literal path. Returns
-* null if it is absolute, contains an empty/dot/traversal segment, is empty, or
-* carries a NUL (no real filesystem produces one, and Postgres rejects it).
-*/
-function safeRelPath(raw) {
-	if (typeof raw !== "string" || raw.length === 0 || raw.includes("\0")) return null;
-	if (raw.startsWith("/") || raw.startsWith("\\") || /^[A-Za-z]:[\\/]/.test(raw)) return null;
-	if (raw.split(/[\\/]/).some((part) => part === "" || part === "." || part === "..")) return null;
-	return raw;
-}
-/** Parse the one canonical sync envelope without coercion or omitted-field defaults. */
-function parseArtifactSyncBody(value) {
-	if (!exactRecord(value, SYNC_FIELDS)) return null;
-	const { loopId, manifest } = value;
-	if (typeof loopId !== "string" || loopId.length === 0 || loopId.length > 200 || loopId.includes("\0") || !Array.isArray(manifest)) return null;
-	const entries = [];
-	const paths = /* @__PURE__ */ new Set();
-	for (const raw of manifest) {
-		if (!exactRecord(raw, MANIFEST_FIELDS)) return null;
-		const { path, hash, size, binary, oversize } = raw;
-		const rel = safeRelPath(path);
-		if (rel === null || paths.has(rel) || typeof size !== "number" || !Number.isSafeInteger(size) || size < 0 || size > MAX_STORED_SIZE || typeof binary !== "boolean" || typeof oversize !== "boolean") return null;
-		if (oversize) {
-			if (size <= 10485760 || hash !== null) return null;
-			entries.push({
-				path: rel,
-				hash: null,
-				size,
-				binary,
-				oversize: true
-			});
-		} else {
-			if (size > 10485760 || !isValidHash(hash)) return null;
-			entries.push({
-				path: rel,
-				hash,
-				size,
-				binary,
-				oversize: false
-			});
-		}
-		paths.add(rel);
-	}
-	return {
-		loopId,
-		manifest: entries
-	};
-}
 /**
 * Machine + run credential helpers. Device tokens (`dk_…`) identify a machine
 * (its id is derived from the token: `m-sha256(token)[:16]`). A run
@@ -2067,8 +2203,8 @@ function validateLoopTags(value) {
 	};
 }
 //#endregion
-//#region node_modules/.nitro/vite/services/ssr/assets/boot-CYRi-wez.js
-var boot_CYRi_wez_exports = /* @__PURE__ */ __exportAll$1({
+//#region node_modules/.nitro/vite/services/ssr/assets/boot-DmpKtb0A.js
+var boot_DmpKtb0A_exports = /* @__PURE__ */ __exportAll$1({
 	_: () => validOptionalPollString,
 	a: () => POLL_HTTP_BODY_FIELDS,
 	c: () => MIN_DAEMON_VERSION,
@@ -2082,24 +2218,11 @@ var boot_CYRi_wez_exports = /* @__PURE__ */ __exportAll$1({
 	n: () => ensureServer,
 	o: () => validPollCurrentRun,
 	p: () => MACHINE_BODY_CAP,
-	r: () => getArtifactSync,
+	r: () => getLoopFiles,
 	s: () => validPollWireId,
 	t: () => boot_exports,
 	u: () => canonicalLoopEnvelope
 });
-/**
-* Machine-route ingress: read + parse a JSON request body under a hard size cap.
-* The gateway's per-field wire caps (WIRE_TEXT_CAP etc.) clip individual strings
-* AFTER parse — without this, an unbounded `request.json()` still buffers an
-* arbitrarily large body first. Framework-free (plain Request) so any machine
-* route can share it.
-*/
-/**
-* Body cap for standard machine routes (poll / report / CLI).
-* 2MB — generously above the largest legitimate terminal report or loop edit.
-* The exact-manifest sync route has its own 32 MB JSON-body cap.
-*/
-var MACHINE_BODY_CAP = 2 * 1024 * 1024;
 /** Read raw request bytes under a hard cap. Declared oversize requests fail
 * before reading; chunked/lying streams are canceled on the first chunk that
 * takes the observed count over the cap. */
@@ -2157,193 +2280,104 @@ async function readJsonBody(request, maxBytes) {
 		body: {}
 	};
 	try {
-		return {
-			kind: "ok",
-			body: JSON.parse(text)
-		};
-	} catch {
-		return { kind: "invalid" };
-	}
-}
-var WIRE_TEXT_CAP = 512 * 1024;
-/** Validate an optional poll string without coercion, clipping, or NUL removal. */
-function validOptionalPollString(value, cap) {
-	return value === void 0 || typeof value === "string" && value.length <= cap && !value.includes("\0");
-}
-function nowIso() {
-	return (/* @__PURE__ */ new Date()).toISOString();
-}
-/** Strip NUL (U+0000) from a wire string: Postgres text/jsonb columns REJECT the
-*  NUL byte (SQLite tolerated it), so a daemon-supplied string carrying one would
-*  throw mid-finalize on the DB write. The single sanitizing primitive behind
-*  `clipText` - and used directly by `cli.ts`
-*  (parseFlags/validateState, the same one-chokepoint discipline). */
-function stripNul(s) {
-	return s.replace(/\u0000/g, "");
-}
-function clipText(s, cap) {
-	return stripNul(s.slice(0, cap));
-}
-/**
-* Deliver the user's prompt unchanged, followed only by the complete report
-* contract. The run index intentionally remains an internal history fact.
-*/
-function buildRunTask(loop) {
-	return `${loop.prompt}\n\nStatus definitions:\n- keep: ${loop.statusKeep}\n- no-change: ${loop.statusNoChange}\n- block: ${loop.statusBlock}\n\nBefore finishing, call exactly once:\npievo report --message "<summary>" --status <keep|no-change|block>`;
-}
-async function buildDelivery(loop, queuedRun, runToken, roots) {
-	if (queuedRun.runIndex == null) throw new Error(`claimed run ${queuedRun.id} has no history index`);
-	return {
-		runId: queuedRun.id,
-		runIndex: queuedRun.runIndex,
-		runToken,
-		roots,
-		loop: {
-			id: loop.id,
-			name: loop.name,
-			workdir: loop.workdir,
-			model: loop.model ?? null,
-			reasoningEffort: loop.reasoningEffort ?? null,
-			agent: loop.agent
-		},
-		task: buildRunTask(loop),
-		artifacts: loop.artifacts
-	};
-}
-/**
-* Content-addressed blob byte store for live-synced loop artifacts.
-*
-* Bytes are keyed by their sha256 hash (content-addressed ⇒ deduped across every
-* loop/run). The store ONLY writes/reads bytes — it never executes or interprets
-* them — preserving the server's zero-exec invariant.
-*
-* `LocalBlobStore` is the durable store under `<dataDir>/blobs`;
-* `MemoryBlobStore` is the injected test fake.
-*/
-var log$4 = logger.child({ mod: "blobstore" });
-var SHA256_HEX = /^[a-f0-9]{64}$/;
-/** Durable filesystem adapter. Hash sharding bounds entries per directory; atomic
-* temp-file renames ensure readers see either complete bytes or no object. */
-var LocalBlobStore = class {
-	root;
-	initialized;
-	constructor(root = path.join(dataDir(), "blobs")) {
-		this.root = root;
-	}
-	file(hash) {
-		if (!SHA256_HEX.test(hash)) throw new Error("invalid sha256 blob key");
-		return path.join(this.root, hash.slice(0, 2), hash);
-	}
-	async has(hash) {
-		const target = this.file(hash);
-		await this.ensureInitialized();
-		try {
-			return (await fs$1.stat(target)).isFile();
-		} catch (err) {
-			if (err.code === "ENOENT") return false;
-			throw err;
-		}
-	}
-	async syncDir(dir) {
-		let handle;
-		try {
-			handle = await fs$1.open(dir, "r");
-			await handle.sync();
-		} catch (err) {
-			const code = err.code;
-			if (![
-				"EINVAL",
-				"ENOTSUP",
-				"EBADF",
-				"EPERM",
-				"ENOENT"
-			].includes(code)) throw err;
-		} finally {
-			await handle?.close().catch(() => {});
-		}
-	}
-	ensureInitialized() {
-		return this.initialized ??= (async () => {
-			await fs$1.mkdir(this.root, { recursive: true });
-			await this.syncDir(path.dirname(path.dirname(this.root)));
-			await this.syncDir(path.dirname(this.root));
-			await this.syncDir(this.root);
-			for (const shard of await fs$1.readdir(this.root, { withFileTypes: true })) {
-				if (!shard.isDirectory() || !/^[a-f0-9]{2}$/.test(shard.name)) continue;
-				const dir = path.join(this.root, shard.name);
-				let removed = false;
-				for (const name of await fs$1.readdir(dir)) {
-					if (!/^\.[a-f0-9]{64}\.\d+\.[0-9a-f-]+\.tmp$/.test(name)) continue;
-					await fs$1.rm(path.join(dir, name), { force: true });
-					removed = true;
-				}
-				if (removed) await this.syncDir(dir);
-			}
-		})();
-	}
-	async put(hash, bytes) {
-		const target = this.file(hash);
-		await this.ensureInitialized();
-		const dir = path.dirname(target);
-		await fs$1.mkdir(dir, { recursive: true });
-		await this.syncDir(this.root);
-		const temp = path.join(dir, `.${hash}.${process.pid}.${randomUUID()}.tmp`);
-		let handle;
-		try {
-			handle = await fs$1.open(temp, "wx", 384);
-			await handle.writeFile(bytes);
-			await handle.sync();
-			await handle.close();
-			handle = void 0;
-			try {
-				await fs$1.rename(temp, target);
-				await this.syncDir(dir);
-			} catch (err) {
-				if ([
-					"EEXIST",
-					"EACCES",
-					"EPERM"
-				].includes(err.code ?? "") && await this.has(hash)) {
-					await fs$1.rm(temp, { force: true });
-					return;
-				}
-				throw err;
-			}
-		} catch (err) {
-			await handle?.close().catch(() => {});
-			await fs$1.rm(temp, { force: true }).catch(() => {});
-			throw err;
-		}
-	}
-	async get(hash) {
-		const target = this.file(hash);
-		await this.ensureInitialized();
-		try {
-			return await fs$1.readFile(target);
-		} catch (err) {
-			if (err.code === "ENOENT") return null;
-			throw err;
-		}
-	}
-	async delete(hash) {
-		const target = this.file(hash);
-		await this.ensureInitialized();
-		await fs$1.rm(target, { force: true });
-		await this.syncDir(path.dirname(target));
+		return {
+			kind: "ok",
+			body: JSON.parse(text)
+		};
+	} catch {
+		return { kind: "invalid" };
 	}
-};
-/** The one local blob store shared by sync writes, artifact reads, and GC. */
-function createBlobStore() {
-	const local = new LocalBlobStore();
-	log$4.info({ root: local.root }, "blob store: local filesystem");
-	return local;
+}
+var WIRE_TEXT_CAP = 512 * 1024;
+/** Validate an optional poll string without coercion, clipping, or NUL removal. */
+function validOptionalPollString(value, cap) {
+	return value === void 0 || typeof value === "string" && value.length <= cap && !value.includes("\0");
+}
+function nowIso() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+/** Strip NUL (U+0000) from a wire string: Postgres text/jsonb columns REJECT the
+*  NUL byte (SQLite tolerated it), so a daemon-supplied string carrying one would
+*  throw mid-finalize on the DB write. The single sanitizing primitive behind
+*  `clipText` - and used directly by `cli.ts`
+*  (parseFlags/validateState, the same one-chokepoint discipline). */
+function stripNul(s) {
+	return s.replace(/\u0000/g, "");
+}
+function clipText(s, cap) {
+	return stripNul(s.slice(0, cap));
+}
+/** Literal placeholder the daemon replaces with the run's absolute loop-file
+*  directory before launch (and exports as an env var of the same name). */
+var LOOP_DIR_PLACEHOLDER = "$PIEVO_LOOP_DIR";
+var STATUS_LINE_RE = /^STATUS:\s*(keep|no-change|block)\.?$/i;
+/**
+* Deliver the user's prompt unchanged, followed by the status definitions, the
+* loop-file contract, and the final-line status contract. The run index
+* intentionally remains an internal history fact.
+*/
+function buildRunTask(loop, previousNotices = []) {
+	const files = [`- ${MEMORY_FILE}: this loop's memory, kept across runs (max ${MEMORY_CHAR_CAP} characters). Read it before you start. Before finishing, update it with anything that would help future runs avoid mistakes or work faster. Keep it concise: merge similar notes, delete stale or wrong ones, no run logs.`, ...loop.artifacts.map((name) => `- ${name}: artifact shown on the Pievo dashboard (max 2 MB). Update it only as the task above asks.`)];
+	const notices = previousNotices.length ? `\n\nNotices from the previous run:\n${previousNotices.map((notice) => `- ${notice}`).join("\n")}` : "";
+	return `${loop.prompt}
+
+Status definitions:
+- keep: ${loop.statusKeep}
+- no-change: ${loop.statusNoChange}
+- block: ${loop.statusBlock}
+
+Loop files in ${LOOP_DIR_PLACEHOLDER}:
+${files.join("\n")}
+A file over its limit is rejected and its previous version kept. Other files in that directory are discarded.${notices}
+
+End your final response with a short summary, then exactly one last line:
+STATUS: keep|no-change|block`;
 }
 /**
-* Artifact-storage retention + garbage collection — the policy that keeps the
+* Split a provider's final response into the reported status and summary. The
+* final non-empty line must be the status line; markdown emphasis or code ticks
+* around it are tolerated because models add them unprompted.
+*/
+function parseFinalStatus(finalText) {
+	if (!finalText) return void 0;
+	const lines = finalText.split(/\r?\n/);
+	let index = lines.length - 1;
+	while (index >= 0 && lines[index].trim() === "") index--;
+	if (index < 0) return void 0;
+	const bare = lines[index].trim().replace(/^[*_`>\s]+|[*_`\s]+$/g, "");
+	const match = STATUS_LINE_RE.exec(bare);
+	if (!match) return void 0;
+	return {
+		status: match[1].toLowerCase(),
+		message: lines.slice(0, index).join("\n").trim()
+	};
+}
+async function buildDelivery(loop, queuedRun, runToken, roots) {
+	if (queuedRun.runIndex == null) throw new Error(`claimed run ${queuedRun.id} has no history index`);
+	const notices = await previousRunFileNotices(loop.id, queuedRun.runIndex);
+	return {
+		runId: queuedRun.id,
+		runIndex: queuedRun.runIndex,
+		runToken,
+		roots,
+		loop: {
+			id: loop.id,
+			name: loop.name,
+			workdir: loop.workdir,
+			model: loop.model ?? null,
+			reasoningEffort: loop.reasoningEffort ?? null,
+			agent: loop.agent
+		},
+		task: buildRunTask(loop, notices),
+		files: loopFileNames(loop)
+	};
+}
+/**
+* Loop-file storage retention + garbage collection — the policy that keeps the
 * local byte store from growing monotonically.
 *
-* The artifact pipeline is content-addressed: blob BYTES are keyed by sha256 and
-* deduped across every loop/run. When a path is deleted or its content changes,
+* The loop-file pipeline is content-addressed: blob BYTES are keyed by sha256 and
+* deduped across every loop/run. When a file is deleted or its content changes,
 * the OLD blob is no longer pointed at by the current file row — but nothing was
 * reclaiming it, so the byte store grew forever. This module closes that gap with two pieces:
 *
@@ -2354,18 +2388,18 @@ function createBlobStore() {
 *      hash. CORRECTNESS over aggressiveness — a still-referenced blob is never
 *      deleted; a leaked blob is only a cost bug the next pass reclaims.
 *
-* Concurrency: gcBlobs is safe to run alongside active syncs. Three guards combine —
-* a grace window (a blob whose metadata row is younger than the window is never
-* collected, so a blob a sync just wrote/referenced is untouchable), a point
-* re-check of each candidate immediately before its bytes are deleted (so a blob
+* Concurrency: gcBlobs is safe alongside owner writes and run uploads. Three guards
+* combine — a grace window (a blob whose metadata row is younger than the window is
+* never collected, so a blob a run just uploaded is untouchable), a point re-check
+* of each candidate immediately before its bytes are deleted (so a blob
 * re-referenced before we touch it keeps both its bytes and metadata), and a
 * bytes-before-metadata delete ordering: each candidate's bytes are reclaimed
 * FIRST, then its metadata row is dropped unconditionally — so blobExists() goes
-* false and any sync that re-references the hash (even one that raced the byte
+* false and any writer that re-references the hash (even one that raced the byte
 * delete) re-uploads the bytes (self-healing). We never leave a live blobs row
 * pointing at deleted bytes.
 */
-var log$3 = logger.child({ mod: "retention" });
+var log$2 = logger.child({ mod: "retention" });
 /**
 * Prune every loop's run snapshots down to the configured retention window
 * (most-recent-N). Returns the total number pruned. This is what makes an old
@@ -2418,7 +2452,7 @@ async function gcBlobs(blobStore, graceMs = BLOB_GC_GRACE_MS) {
 			await deleteBlob(hash);
 			reclaimed++;
 		} catch (err) {
-			log$3.warn({
+			log$2.warn({
 				hash,
 				err: err instanceof Error ? err.message : String(err)
 			}, "gc: blob byte-delete failed");
@@ -2429,7 +2463,7 @@ async function gcBlobs(blobStore, graceMs = BLOB_GC_GRACE_MS) {
 async function maintainStorage(blobStore, options = {}) {
 	const snapshotsPruned = await pruneSnapshots(options.keep);
 	const blobsReclaimed = await gcBlobs(blobStore, options.graceMs);
-	if (snapshotsPruned || blobsReclaimed) log$3.info({
+	if (snapshotsPruned || blobsReclaimed) log$2.info({
 		snapshotsPruned,
 		blobsReclaimed
 	}, "storage maintenance");
@@ -2764,44 +2798,37 @@ function validateStatusDefinitions(value) {
 		}
 	};
 }
-function validateArtifactPaths(value) {
+function validateArtifactNames(value) {
 	if (value === void 0 || value === null) return {
 		ok: true,
 		value: []
 	};
 	if (!Array.isArray(value)) return {
 		ok: false,
-		detail: "artifacts must be an array of exact relative file paths"
+		detail: "artifacts must be an array of file names"
+	};
+	if (value.length > 4) return {
+		ok: false,
+		detail: `at most 4 artifacts are allowed`
 	};
-	const paths = [];
+	const names = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const entry of value) {
-		if (typeof entry !== "string" || entry.length === 0) return {
-			ok: false,
-			detail: "artifact paths must be non-empty strings"
-		};
-		if (entry.includes("\0")) return {
-			ok: false,
-			detail: "artifact path must not contain NUL"
-		};
-		if (entry.startsWith("/") || entry.startsWith("\\") || /^[A-Za-z]:[\\/]/.test(entry)) return {
-			ok: false,
-			detail: `artifact path must be relative to workdir: ${entry}`
-		};
-		if (entry.split(/[\\/]/).some((part) => part === "" || part === "." || part === "..")) return {
+		if (!validArtifactName(entry)) return {
 			ok: false,
-			detail: `artifact path must not traverse or alias another path: ${entry}`
+			detail: `artifact must be a plain .md or .html file name other than ${MEMORY_FILE} (letters, digits, . _ -; at most 64 characters before the extension): ${JSON.stringify(entry)}`
 		};
-		if (seen.has(entry)) return {
+		const key = entry.toLowerCase();
+		if (seen.has(key)) return {
 			ok: false,
-			detail: `duplicate artifact path: ${entry}`
+			detail: `duplicate artifact name: ${entry}`
 		};
-		seen.add(entry);
-		paths.push(entry);
+		seen.add(key);
+		names.push(entry);
 	}
 	return {
 		ok: true,
-		value: paths
+		value: names
 	};
 }
 function rowSchedule(schedule, retainedCron = SAFE_RETAINED_CRON) {
@@ -2886,7 +2913,7 @@ function validateLoopCreate(value) {
 	if (!schedule.ok) return schedule;
 	const statusDefinitions = validateStatusDefinitions(raw.statusDefinitions);
 	if (!statusDefinitions.ok) return statusDefinitions;
-	const artifacts = validateArtifactPaths(raw.artifacts);
+	const artifacts = validateArtifactNames(raw.artifacts);
 	if (!artifacts.ok) return artifacts;
 	const model = optionalProvider(raw.model, "model");
 	if (!model.ok) return model;
@@ -2981,7 +3008,7 @@ function validateLoopEdit(loop, value) {
 		update.statusBlock = result.value.block;
 	}
 	if (raw.artifacts !== void 0) {
-		const result = validateArtifactPaths(raw.artifacts);
+		const result = validateArtifactNames(raw.artifacts);
 		if (!result.ok) return result;
 		update.artifacts = result.value;
 	}
@@ -3017,7 +3044,7 @@ function validateLoopEdit(loop, value) {
 		value: update
 	};
 }
-var MIN_DAEMON_VERSION = "2.4.0";
+var MIN_DAEMON_VERSION = "4.0.0";
 function daemonNeedsUpdate(current, required = MIN_DAEMON_VERSION) {
 	if (!current || !isValidSemver(current) || !isValidSemver(required)) return true;
 	if (current === required) return false;
@@ -3058,6 +3085,7 @@ var validPollInfo = (value) => value === void 0 || value !== null && typeof valu
 *
 *   POST /api/machine/poll   (Bearer device token) → claim pending runs, deliver
 *   POST /machine/report     (Bearer run token)    → finalize a run
+*   GET|PUT /api/machine/run-files/:name (Bearer run token) → loop-file transfer
 *
 * plus owner create/list/edit methods and retention.
 * Also exposes `dispatcher` (a `Dispatcher` for the Scheduler: "is the machine
@@ -3066,7 +3094,7 @@ var validPollInfo = (value) => value === void 0 || value !== null && typeof valu
 * (`CliGateway`), which reuses this class's owner methods;
 * canonical loop configuration validation lives in `gateway/loopConfig.ts`.
 */
-var log$2 = logger.child({ mod: "gateway" });
+var log$1 = logger.child({ mod: "gateway" });
 var ONLINE_TTL_MS = 3e4;
 /** Auto-pause after this many consecutive errors. Canceled rows are transparent;
 *  zero disables the breaker. */
@@ -3081,10 +3109,15 @@ var RUN_TIMEOUT_MS = Number.isFinite(configuredRunTimeoutMs) && configuredRunTim
 *  patched over the device-token edit surface. Exported for `cli.ts`
 *  (the `new`/`edit` verb help lists these keys). */
 var EDITABLE_LOOP_FIELDS = LOOP_EDIT_FIELDS;
-/** Formal `report --message` text. Provider finalText is stored separately;
-*  it never satisfies the successful-run reporting protocol. Run errors share
-*  this cap. Exported for `cli.ts` so the report verb uses the same budget. */
+/** Run summary (the final response minus its STATUS line) and run errors share
+*  this cap; the full final response is stored separately as finalText. */
 var MESSAGE_CAP = 2e3;
+/** A run reports at most one version per loop file (MEMORY.md + 4 artifacts). */
+var REPORT_FILES_MAX = 5;
+/** One notice per file plus a few upload/rejection reasons; bounds the prompt echo. */
+var REPORT_NOTICES_MAX = 10;
+/** One short sentence (name + reason); 500 chars keeps the next prompt small. */
+var NOTICE_CAP = 500;
 /** Provider session IDs are opaque short tokens; this rejects malformed payloads
 *  without constraining known provider formats. */
 var SESSION_ID_CAP = 200;
@@ -3099,7 +3132,7 @@ var HEARTBEAT_STAMP_REFRESH_MS = heartbeatRefreshMs(RUN_TIMEOUT_MS);
 *  and an idle poll becomes read-only, with worst-case staleness well inside
 *  the 30s TTL (max stamp gap = refresh + one poll interval). */
 var LAST_SEEN_REFRESH_MS = 1e4;
-var MACHINE_REPORT_FIELD_SET = new Set([
+var MACHINE_REPORT_FIELDS = [
 	"reportId",
 	"runId",
 	"result",
@@ -3108,8 +3141,17 @@ var MACHINE_REPORT_FIELD_SET = new Set([
 	"sessionId",
 	"usage",
 	"error",
-	"finalText"
-]);
+	"finalText",
+	"files",
+	"fileNotices"
+];
+var REPORT_FILE_FIELDS = [
+	"baseHash",
+	"hash",
+	"name",
+	"size"
+];
+var MACHINE_REPORT_FIELD_SET = new Set(MACHINE_REPORT_FIELDS);
 var MACHINE_REPORT_USAGE_FIELDS = new Set([
 	"inputTokens",
 	"outputTokens",
@@ -3138,7 +3180,7 @@ function receiptFor(body, runId, ackStatus = 200, ackBody) {
 }
 function receiptResponse(receipt, expected) {
 	if (!receipt || receipt.runId !== expected.runId) return void 0;
-	if (receipt.payloadDigest !== expected.payloadDigest) log$2.warn({
+	if (receipt.payloadDigest !== expected.payloadDigest) log$1.warn({
 		reportId: expected.reportId,
 		runId: expected.runId
 	}, "report: same-run payload changed after commit; replaying authoritative ACK");
@@ -3166,7 +3208,7 @@ async function committedReportEvidence(reportId, payloadDigest, authoritativeRun
 			foreignRun: false
 		};
 		if (normal?.runId === authoritativeRunId) {
-			if (normal.payloadDigest !== payloadDigest) log$2.warn({
+			if (normal.payloadDigest !== payloadDigest) log$1.warn({
 				reportId,
 				runId: authoritativeRunId
 			}, "report: same-run payload changed after commit; replaying authoritative ACK");
@@ -3200,14 +3242,36 @@ function incidentDiagnosis(code, issues, reportId, payloadDigest) {
 		recommendedAction
 	};
 }
-/** Validate the durable report facts before a successful provider process may
-* become a successful run. The CLI validates first so an agent can retry; this
-* terminal seam prevents an ignored 400 from silently producing an empty run. */
-function runProtocolMissing(run) {
-	const missing = [];
-	if (run.status !== "keep" && run.status !== "no-change" && run.status !== "block") missing.push("status");
-	if (!run.message?.trim()) missing.push("message");
-	return missing;
+var MISSING_STATUS_ERROR = "run protocol incomplete: the final response has no \"STATUS: keep|no-change|block\" line";
+/** The run outcome a terminal report establishes. Only a successful provider
+* exit is read for a status; a successful exit without one is a protocol error. */
+function reportOutcome(body) {
+	const canceled = body.result === "canceled";
+	if (canceled) return {
+		ok: false,
+		canceled,
+		patch: { error: "stopped by user" }
+	};
+	if (body.result !== "success") return {
+		ok: false,
+		canceled,
+		patch: { error: typeof body.error === "string" ? clipText(body.error, MESSAGE_CAP) : "run failed on machine" }
+	};
+	const parsed = parseFinalStatus(body.finalText);
+	if (!parsed) return {
+		ok: false,
+		canceled,
+		patch: { error: MISSING_STATUS_ERROR }
+	};
+	return {
+		ok: true,
+		canceled,
+		patch: {
+			status: parsed.status,
+			message: clipText(parsed.message, 2e3) || null,
+			error: null
+		}
+	};
 }
 function validateTerminalReport(body) {
 	const issues = [];
@@ -3227,6 +3291,25 @@ function validateTerminalReport(body) {
 		"error",
 		"finalText"
 	]) if (has(key) && typeof body[key] !== "string") issues.push(`${key} must be a string`);
+	if (has("files")) {
+		const files = body.files;
+		if (!Array.isArray(files) || files.length > REPORT_FILES_MAX) issues.push(`files must be an array of at most ${REPORT_FILES_MAX} entries`);
+		else {
+			const names = /* @__PURE__ */ new Set();
+			for (const entry of files) {
+				const file = entry;
+				if (!(file !== null && typeof file === "object" && !Array.isArray(file) && Object.keys(file).sort().join(",") === REPORT_FILE_FIELDS.join(",") && typeof file.name === "string" && file.name.length > 0 && file.name.length <= 100 && !names.has(file.name) && isValidHash(file.baseHash) && isValidHash(file.hash) && typeof file.size === "number" && Number.isInteger(file.size) && file.size >= 0 && file.size <= LOOP_FILE_BYTE_CAP)) {
+					issues.push("files entries must be exactly {name, baseHash, hash, size} with unique names, sha256 hashes, and an in-cap size");
+					break;
+				}
+				names.add(file.name);
+			}
+		}
+	}
+	if (has("fileNotices")) {
+		const notices = body.fileNotices;
+		if (!Array.isArray(notices) || notices.length > REPORT_NOTICES_MAX || notices.some((notice) => typeof notice !== "string" || notice.length > NOTICE_CAP)) issues.push(`fileNotices must be an array of at most ${REPORT_NOTICES_MAX} strings of at most ${NOTICE_CAP} characters`);
+	}
 	if (has("usage")) if (body.usage === null || typeof body.usage !== "object" || Array.isArray(body.usage)) issues.push("usage must be an object");
 	else {
 		const usage = body.usage;
@@ -3267,7 +3350,10 @@ var MachineGateway = class {
 	constructor(scheduler, blobStore = createBlobStore()) {
 		this.scheduler = scheduler;
 		this.blobStore = blobStore;
+		this.loopFiles = new LoopFiles(blobStore);
 	}
+	/** Loop-file bytes over the same blob store that maintenance garbage-collects. */
+	loopFiles;
 	/** In-flight latch: the maintenance pass is sequential and the first post-deploy
 	*  backlog reclamation can overrun the interval, so a fresh tick skips rather than
 	*  running a second pass concurrently (idempotent but wasteful + double-counts). */
@@ -3275,7 +3361,7 @@ var MachineGateway = class {
 	applyAutopauseTimer(loopId, terminal) {
 		if (!terminal.autoPaused) return;
 		this.scheduler.removeLoop(loopId);
-		log$2.warn({
+		log$1.warn({
 			loopId,
 			streak: terminal.failureStreak
 		}, "loop auto-paused after block or consecutive errors");
@@ -3371,13 +3457,14 @@ var MachineGateway = class {
 	* Periodic storage maintenance: prune each loop's run snapshots to the
 	* retention window, then GC blob bytes no live row needs. Wired to its own
 	* interval in boot (independent of the faster offline-sweep) and exposed for
-	* tests / on-demand triggers. Safe to run concurrently with active syncs (a
-	* grace window + final re-check protect freshly-written/referenced blobs) and
-	* idempotent with no garbage. Best-effort — never throws into the caller.
+	* tests / on-demand triggers. Safe to run concurrently with owner writes and
+	* run uploads (a grace window + final re-check protect freshly-written or
+	* referenced blobs) and idempotent with no garbage. Best-effort — never throws
+	* into the caller.
 	*/
 	async maintainStorage(options) {
 		if (this.maintenanceRunning) {
-			log$2.info("storage maintenance already in progress — skipping this tick");
+			log$1.info("storage maintenance already in progress — skipping this tick");
 			return {
 				snapshotsPruned: 0,
 				blobsReclaimed: 0
@@ -3387,7 +3474,7 @@ var MachineGateway = class {
 		try {
 			return await maintainStorage(this.blobStore, options);
 		} catch (err) {
-			log$2.warn({ err: err instanceof Error ? err.message : String(err) }, "storage maintenance failed");
+			log$1.warn({ err: err instanceof Error ? err.message : String(err) }, "storage maintenance failed");
 			return {
 				snapshotsPruned: 0,
 				blobsReclaimed: 0
@@ -3413,7 +3500,7 @@ var MachineGateway = class {
 				token: deviceToken,
 				online: true
 			});
-			log$2.info({
+			log$1.info({
 				machineId,
 				host: info?.host
 			}, "poll: self-registered machine");
@@ -3445,7 +3532,7 @@ var MachineGateway = class {
 			const claimed = await claimReadyRunForMachine(machineId, void 0, currentRunIds ?? []);
 			if (claimed) delivery = await buildDelivery(claimed.loop, claimed.run, claimed.runToken, machine.roots ?? []);
 		}
-		if (delivery) log$2.info({
+		if (delivery) log$1.info({
 			machineId,
 			runId: delivery.runId
 		}, "poll: delivered");
@@ -3463,7 +3550,7 @@ var MachineGateway = class {
 				code: "VALIDATION_ERROR"
 			}
 		};
-		if (request.protocolVersion !== 4) {
+		if (request.protocolVersion !== 5) {
 			const auth = await authenticateDeviceToken(deviceToken, { allowUnknown: true });
 			if (!auth.ok && auth.reason === "mismatch") return auth.response;
 			if (auth.ok && auth.machine) {
@@ -3475,7 +3562,7 @@ var MachineGateway = class {
 				body: {
 					error: "daemon upgrade required; run `npm install -g @kky42/pievo@latest`, then `pievo daemon restart`",
 					code: "UPGRADE_REQUIRED",
-					requiredProtocol: 4
+					requiredProtocol: 5
 				}
 			};
 		}
@@ -3507,7 +3594,7 @@ var MachineGateway = class {
 		const needsUpdate = daemonNeedsUpdate(reportedVersion);
 		const base = await this.pollCore(deviceToken, request.info, currentIds, !needsUpdate, true);
 		if (base.status !== 200) return base;
-		if ((await getMachine(machineId))?.daemonProtocol !== 4) await updateMachine(machineId, { daemonProtocol: 4 });
+		if ((await getMachine(machineId))?.daemonProtocol !== 5) await updateMachine(machineId, { daemonProtocol: 5 });
 		const running = await runningRunsForMachine(machineId);
 		const currentSet = new Set(currentIds);
 		return {
@@ -3524,7 +3611,7 @@ var MachineGateway = class {
 		};
 	}
 	async pollV4Wait(deviceToken, request, waitMs = LONG_POLL_WAIT_MS) {
-		if (request.currentRuns?.length || request.protocolVersion !== 4) return this.pollV4(deviceToken, request);
+		if (request.currentRuns?.length || request.protocolVersion !== 5) return this.pollV4(deviceToken, request);
 		const auth = await authenticateDeviceToken(deviceToken, { allowUnknown: true });
 		if (!auth.ok) return auth.response;
 		const machineId = auth.machineId;
@@ -3632,7 +3719,7 @@ var MachineGateway = class {
 			});
 			this.scheduler.addLoop(loop);
 			recordNewIdempotency(idempotencyKey, machineId, loop.id);
-			log$2.info({
+			log$1.info({
 				machineId,
 				loopId: loop.id,
 				agent: loop.agent
@@ -3846,7 +3933,7 @@ var MachineGateway = class {
 		}
 		const response = receiptResponse(stored, expected);
 		if (response.status < 300) await retireLease(runToken);
-		log$2.info({ runId: lease.runId }, "report: ignored (run was canceled)");
+		log$1.info({ runId: lease.runId }, "report: ignored (run was canceled)");
 		return response;
 	}
 	async reportRaceResponse(runToken, lease, body, payloadDigest) {
@@ -3870,7 +3957,7 @@ var MachineGateway = class {
 		const refreshedLease = await resolveLease(runToken);
 		if (refreshedLease?.state === "retired") return this.retiredReport(runToken, body, lease.runId);
 		if (retryReconcile && fresh?.phase === "error" && refreshedLease?.state === "terminal-grace") return this.reconcileReclaimedReport(runToken, refreshedLease, fresh, body);
-		log$2.info({
+		log$1.info({
 			runId: lease.runId,
 			phase: fresh?.phase
 		}, logMessage);
@@ -3883,12 +3970,108 @@ var MachineGateway = class {
 			}
 		};
 	}
+	/** Reported loop-file versions whose uploaded bytes are present. A canceled run
+	* was killed mid-edit, so none of its files are applied. */
+	async terminalFiles(body) {
+		const notices = (body.fileNotices ?? []).map((notice) => clipText(notice, NOTICE_CAP));
+		const updates = [];
+		if (body.result === "canceled") return {
+			updates,
+			notices
+		};
+		const files = body.files ?? [];
+		const sizes = await blobSizes(files.map((file) => file.hash).filter((hash) => hash !== EMPTY_SHA256));
+		for (const file of files) {
+			if (!await this.loopFiles.hasBlob(file.hash)) {
+				notices.push(`${file.name}: the upload was lost; the previous version was kept`);
+				continue;
+			}
+			const size = file.hash === "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" ? 0 : sizes.get(file.hash);
+			if (size === void 0 || size !== file.size) {
+				notices.push(`${file.name}: reported size did not match the stored version; the previous version was kept`);
+				continue;
+			}
+			updates.push({
+				name: file.name,
+				baseHash: file.baseHash,
+				hash: file.hash,
+				size
+			});
+		}
+		return {
+			updates,
+			notices
+		};
+	}
+	/** Current bytes of one loop file for an executing run (the run's starting version). */
+	async readRunFile(runToken, name) {
+		const lease = await resolveLease(runToken);
+		if (!lease) return {
+			status: 401,
+			body: { error: "invalid or expired token" }
+		};
+		if (lease.state !== "active") return {
+			status: 409,
+			body: { error: "run is no longer executing" }
+		};
+		const loop = await getLoop(lease.loopId);
+		if (!loop || !loopFileNames(loop).includes(name)) return {
+			status: 404,
+			body: { error: "no such loop file" }
+		};
+		const row = await getArtifactFile(loop.id, name);
+		const hash = row && !row.deleted && row.hash ? row.hash : EMPTY_SHA256;
+		const bytes = await this.loopFiles.readBlob(hash);
+		if (!bytes) return {
+			status: 500,
+			body: { error: "loop file bytes are missing" }
+		};
+		return {
+			status: 200,
+			body: {},
+			bytes,
+			hash
+		};
+	}
+	/** Store one loop-file version produced by a run. Accepted until the run's
+	* authority retires, so the durable report outbox can retry after a crash.
+	* Applying it to the loop happens only in the terminal report transaction. */
+	async storeRunFile(runToken, name, bytes, expectedHash) {
+		const lease = await resolveLease(runToken);
+		if (!lease || lease.state === "retired") return {
+			status: 401,
+			body: { error: "invalid or expired token" }
+		};
+		const loop = await getLoop(lease.loopId);
+		if (!loop || !loopFileNames(loop).includes(name)) return {
+			status: 404,
+			body: { error: "no such loop file" }
+		};
+		const issue = loopFileIssue(name, bytes);
+		if (issue) return {
+			status: 413,
+			body: { error: issue }
+		};
+		if (expectedHash !== null && expectedHash !== sha256Buf(bytes)) return {
+			status: 400,
+			body: { error: "hash mismatch" }
+		};
+		const hash = await this.loopFiles.putBlob(bytes);
+		if (hash !== "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855") await recordBlob(hash, bytes.length);
+		return {
+			status: 200,
+			body: {
+				ok: true,
+				hash
+			}
+		};
+	}
 	async captureRunSnapshot(runId, loopId) {
 		try {
 			await putRunSnapshot(runId, loopId, await buildLoopManifest(loopId));
 			await pruneRunSnapshots(loopId, 20);
 		} catch (err) {
-			log$2.warn({
+			log$1.warn({
 				runId,
 				err: err instanceof Error ? err.message : String(err)
 			}, "snapshot capture failed");
@@ -3898,11 +4081,8 @@ var MachineGateway = class {
 	* same loop-lock transaction as the error→done/error patch and loop state, so
 	* concurrent late reports cannot both win (including error→error). */
 	async reconcileReclaimedReport(runToken, lease, run, body) {
-		const providerOk = body.result === "success";
-		const canceled = body.result === "canceled";
-		const protocolMissing = providerOk ? runProtocolMissing(run) : [];
-		const ok = providerOk && protocolMissing.length === 0;
-		const message = run.message ?? void 0;
+		const { ok, canceled, patch } = reportOutcome(body);
+		const files = await this.terminalFiles(body);
 		const loopPatch = {};
 		const receipt = receiptFor(body, lease.runId);
 		const payloadDigest = sha256(JSON.stringify(body));
@@ -3911,10 +4091,10 @@ var MachineGateway = class {
 			reconciled = await reconcileReclaimedRun(lease.loopId, lease.runId, sha256(runToken), {
 				phase: canceled ? "canceled" : ok ? "done" : "error",
 				...coerceTelemetry(body),
-				...message !== void 0 ? { message } : {},
-				...canceled ? { error: "stopped by user" } : protocolMissing.length ? { error: `run protocol incomplete: missing ${protocolMissing.join(", ")}` } : ok ? { error: null } : { error: typeof body.error === "string" ? clipText(body.error, MESSAGE_CAP) : run.error },
+				...patch,
+				fileNotices: files.notices,
 				ts: nowIso()
-			}, loopPatch, AUTOPAUSE_STREAK, receipt);
+			}, loopPatch, AUTOPAUSE_STREAK, receipt, files.updates);
 		} catch (error) {
 			const raced = await this.reportRaceResponse(runToken, lease, body, payloadDigest);
 			if (raced) return raced;
@@ -3927,7 +4107,7 @@ var MachineGateway = class {
 		if (!reportOnly) this.scheduler.addLoop(reconciled.loop);
 		if (!reportOnly) this.applyAutopauseTimer(lease.loopId, reconciled);
 		if (deleting) await tryDeleteLoop(lease.loopId);
-		log$2.info({
+		log$1.info({
 			runId: lease.runId,
 			ok,
 			reclaimed: true
@@ -3980,7 +4160,7 @@ var MachineGateway = class {
 			this.scheduler.addLoop(rejected.loop);
 			if (rejected.state === "run-error") this.applyAutopauseTimer(lease.loopId, rejected);
 			if (rejected.loop.deleteRequestedAt) await tryDeleteLoop(lease.loopId);
-			log$2.warn({
+			log$1.warn({
 				runId: lease.runId,
 				reportId,
 				code,
@@ -4034,8 +4214,6 @@ var MachineGateway = class {
 		if (evidence.foreignRun) return this.rejectTerminalAttempt(runToken, lease, body, payloadDigest, "REPORT_CONFLICT", ["reportId was already committed for another run"]);
 		if (issues.length) return this.rejectTerminalAttempt(runToken, lease, body, payloadDigest, "REPORT_INVALID", issues);
 		const expected = receiptFor(body, lease.runId);
-		const ok = body.result === "success";
-		const canceled = body.result === "canceled";
 		const run = await getRun(lease.runId);
 		if (run?.phase === "canceled") return this.ignoreCanceledReport(runToken, lease, body);
 		if (run?.phase === "done") return {
@@ -4047,17 +4225,18 @@ var MachineGateway = class {
 			}
 		};
 		if (run?.phase === "error" && (lease.state === "terminal-grace" || lease.state === "reconciliation-only")) return this.reconcileReclaimedReport(runToken, lease, run, body);
-		const protocolMissing = ok && run ? runProtocolMissing(run) : [];
-		const effectiveOk = ok && protocolMissing.length === 0;
+		const { ok: effectiveOk, canceled, patch } = reportOutcome(body);
+		const files = await this.terminalFiles(body);
 		const loopPatch = {};
 		let terminal;
 		try {
 			terminal = await finalizeRunningRun(lease.loopId, lease.runId, {
 				phase: canceled ? "canceled" : effectiveOk ? "done" : "error",
 				...coerceTelemetry(body),
-				...canceled ? { error: "stopped by user" } : protocolMissing.length ? { error: `run protocol incomplete: missing ${protocolMissing.join(", ")}` } : effectiveOk ? {} : { error: typeof body.error === "string" ? clipText(body.error, MESSAGE_CAP) : "run failed on machine" },
+				...patch,
+				fileNotices: files.notices,
 				ts: nowIso()
-			}, loopPatch, sha256(runToken), AUTOPAUSE_STREAK, expected);
+			}, loopPatch, sha256(runToken), AUTOPAUSE_STREAK, expected, files.updates);
 		} catch (error) {
 			const raced = await this.reportRaceResponse(runToken, lease, body, payloadDigest);
 			if (raced) return raced;
@@ -4068,7 +4247,7 @@ var MachineGateway = class {
 		if (!deleting) await this.captureRunSnapshot(lease.runId, lease.loopId);
 		this.scheduler.addLoop(terminal.loop);
 		this.applyAutopauseTimer(lease.loopId, terminal);
-		log$2.info({
+		log$1.info({
 			runId: lease.runId,
 			ok: effectiveOk
 		}, "report: finalized");
@@ -4182,157 +4361,9 @@ function nextFires(cron, timezone, n) {
 	}
 }
 /**
-* Artifact sync - the byte-ingress half of the machine gateway, split out of
-* `MachineGateway` (which keeps poll/report/CLI/retention). Same wire surface,
-* framework-agnostic like the rest of the gateway (`{ status, body }` results):
-*
-*   POST /api/machine/sync        (Bearer device token) → manifest reconcile
-*   PUT  /api/machine/blob/:hash  (Bearer device token) → negotiated blob upload
-*
-* plus `readBlob` (the download seam the artifact/diff readers resolve bytes
-* through). Boot constructs ONE BlobStore and hands the SAME instance to this
-* class and to `MachineGateway` (whose `maintainStorage` GC deletes the bytes
-* written here).
-*/
-var log$1 = logger.child({ mod: "gateway" });
-var BLOB_PRESENCE_CONCURRENCY = 16;
-async function mapConcurrent(items, limit, visit) {
-	let next = 0;
-	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, async () => {
-		while (next < items.length) {
-			const item = items[next++];
-			await visit(item);
-		}
-	}));
-}
-var ArtifactSync = class {
-	blobStore;
-	constructor(blobStore = createBlobStore()) {
-		this.blobStore = blobStore;
-	}
-	/**
-	* Reconcile one complete configured-path manifest after a run. Missing hashes
-	* are returned for upload through the raw blob PUT endpoint.
-	*/
-	async sync(deviceToken, rawBody) {
-		const auth = await authenticateDeviceToken(deviceToken);
-		if (!auth.ok) return auth.response;
-		const { machineId } = auth;
-		const body = parseArtifactSyncBody(rawBody);
-		if (!body) return {
-			status: 400,
-			body: { error: "invalid sync body" }
-		};
-		const { loopId, manifest } = body;
-		const loop = await getLoop(loopId);
-		if (!loop || loop.machineId !== machineId) return {
-			status: 404,
-			body: { error: "no such loop on this machine" }
-		};
-		const allowedPaths = new Set(loop.artifacts);
-		if (manifest.some((entry) => !allowedPaths.has(entry.path))) return {
-			status: 400,
-			body: { error: "manifest path is not configured on this loop" }
-		};
-		const keepPaths = [];
-		const needHashes = /* @__PURE__ */ new Set();
-		const storedState = /* @__PURE__ */ new Map();
-		const stateFor = async (hash) => {
-			const cached = storedState.get(hash);
-			if (cached) return cached;
-			const metadata = await blobExists(hash);
-			const state = {
-				metadata,
-				bytes: metadata && await this.blobStore.has(hash)
-			};
-			storedState.set(hash, state);
-			return state;
-		};
-		await mapConcurrent([...new Set(manifest.flatMap((entry) => entry.oversize ? [] : [entry.hash]))], BLOB_PRESENCE_CONCURRENCY, async (hash) => {
-			await stateFor(hash);
-		});
-		for (const entry of manifest) {
-			if (entry.oversize) {
-				if (await upsertConfiguredArtifactFile({
-					loopId,
-					path: entry.path,
-					hash: null,
-					size: entry.size,
-					binary: entry.binary,
-					oversize: true
-				})) keepPaths.push(entry.path);
-				continue;
-			}
-			const hash = entry.hash;
-			const stored = await stateFor(hash);
-			if (!await upsertConfiguredArtifactFile({
-				loopId,
-				path: entry.path,
-				hash,
-				size: entry.size,
-				binary: entry.binary,
-				oversize: false
-			})) continue;
-			if (!stored.bytes) needHashes.add(hash);
-			keepPaths.push(entry.path);
-		}
-		const tombstoned = await reconcileConfiguredArtifacts(loopId, [...allowedPaths], keepPaths);
-		log$1.info({
-			machineId,
-			loopId,
-			files: keepPaths.length,
-			need: needHashes.size,
-			tombstoned
-		}, "sync: reconciled");
-		return {
-			status: 200,
-			body: {
-				ok: true,
-				needHashes: [...needHashes]
-			}
-		};
-	}
-	/**
-	* Upload one content-addressed blob's raw bytes (Bearer device token). The
-	* server recomputes sha256(body) and rejects any mismatch before storing —
-	* integrity + anti-poisoning, so a blob's bytes always match its key.
-	*/
-	async putBlob(deviceToken, hash, bytes) {
-		const auth = await authenticateDeviceToken(deviceToken);
-		if (!auth.ok) return auth.response;
-		const { machineId } = auth;
-		if (!isValidHash(hash)) return {
-			status: 400,
-			body: { error: "invalid hash (expect sha256 hex)" }
-		};
-		if (bytes.length > 10485760) return {
-			status: 413,
-			body: { error: "blob exceeds size cap" }
-		};
-		if (sha256Buf(bytes) !== hash) return {
-			status: 400,
-			body: { error: "hash mismatch (sha256(body) !== :hash)" }
-		};
-		if (!await machineReferencesBlob(machineId, hash)) return {
-			status: 403,
-			body: { error: "hash was not requested for this machine (sync a manifest first)" }
-		};
-		await this.blobStore.put(hash, bytes);
-		await recordBlob(hash, bytes.length);
-		return {
-			status: 200,
-			body: { ok: true }
-		};
-	}
-	readBlob(hash) {
-		if (!isValidHash(hash)) return Promise.resolve(null);
-		return this.blobStore.get(hash);
-	}
-};
-/**
-* Per-run artifact diff. Computed lazily on the server at read time
+* Per-run loop-file diff. Computed lazily on the server at read time
 * (no stored diffs): load run N's snapshot + the previous run's snapshot and diff
-* the two path → metadata maps. For changed TEXT files we load both blobs and
+* the two name → metadata maps. For changed TEXT files we load both blobs and
 * compute a unified line diff with `diff` (jsdiff) — a pure-string library, no
 * process execution, so the server's zero-exec invariant holds. Binary/oversize
 * files emit a size-delta marker only (no inline diff).
@@ -4353,7 +4384,7 @@ function withinDiffCap(e) {
 }
 async function bytesOf(e) {
 	if (!e.hash) return null;
-	return await (await getArtifactSync()).readBlob(e.hash) ?? null;
+	return await (await getLoopFiles()).readBlob(e.hash) ?? null;
 }
 function unified(path, oldText, newText, maxEditLength) {
 	return maxEditLength === void 0 ? createTwoFilesPatch(path, path, oldText, newText, "previous run", "this run") : createTwoFilesPatch(path, path, oldText, newText, "previous run", "this run", { maxEditLength });
@@ -4366,7 +4397,7 @@ function expectedInputBytes(change, verifiedSizes) {
 	if (sizes.some((size) => size === void 0)) return null;
 	return sizes.reduce((sum, size) => sum + size, 0);
 }
-/** Compute one run's artifact diff. The default remains the web UI's complete
+/** Compute one run's loop-file diff. The default remains the web UI's complete
 * view. Budgeted callers get explicit totals and stop before blob reads/jsdiff
 * once any work limit is spent. */
 async function computeRunDiff(runId, budget) {
@@ -4781,6 +4812,7 @@ async function detailHistory(loop, q) {
 		errorTruncated: error.truncated,
 		finalText: finalText.value,
 		finalTextTruncated: finalText.truncated,
+		fileNotices: run.fileNotices ?? [],
 		diffAvailable: !!snapshot,
 		diff: q.diff ? await boundedDiff(run.id) : {
 			included: false,
@@ -4806,6 +4838,7 @@ async function detailHistory(loop, q) {
 		["errorTruncated", detail.errorTruncated],
 		["finalText", detail.finalText],
 		["finalTextTruncated", detail.finalTextTruncated],
+		["fileNotices", { raw: JSON.stringify(detail.fileNotices) }],
 		["diffAvailable", detail.diffAvailable],
 		["diff", { raw: JSON.stringify(detail.diff) }]
 	]));
@@ -4830,8 +4863,8 @@ async function readLoopHistory(loop, flags) {
 * The verb router keys authority on credential type first (`dk_` device prefix
 * vs `rk_` run lease) and reuses the core gateway
 * methods (`createLoop`/`editLoop`) through the injected `MachineGateway`,
-* plus the credential-neutral history module. Run credentials expose only the
-* exactly-once report callback.
+* plus the credential-neutral history module. Run credentials authorize no CLI
+* verb: a run reports through its final response, not a callback.
 */
 var cliLog = logger.child({ mod: "cli" });
 var CliGateway = class {
@@ -4850,9 +4883,8 @@ var CliGateway = class {
 	* already exists — never a rewrite — that keys authority on the credential type:
 	*   · DEVICE credential (`dk_`-prefixed) → owner authority over any loop bound to
 	*     the machine: `new`→createLoop, `loops`→listLoops, `edit`→editLoop,
-	*     `log`→readLoopHistory, `show`→describe. `report` is RUN-only (403).
-	*   · RUN credential (`rk_` run lease) → report and report help only.
-	*     Every owner verb is rejected.
+	*     `log`→readLoopHistory, `show`→describe, `file`→loop files.
+	*   · RUN credential (`rk_` run lease) → rejected; runs have no CLI.
 	*/
 	async cli(token, argv) {
 		return finalizeCli(token.startsWith("dk_") ? await this.deviceCli(token, argv) : await this.runCli(token, argv));
@@ -4943,13 +4975,10 @@ var CliGateway = class {
 					}
 				};
 			}
-			case "report": return {
-				status: 403,
-				body: { error: "pievo: report is a run-only verb; the owner edits via edit" }
-			};
+			case "file": return this.ownerFile(machineId, argv);
 			default: return {
 				status: 400,
-				body: { error: `pievo: unknown command "${verb}" for the device credential (try: new, loops, pause, start, stop, delete, run stop, edit, log, show)` }
+				body: { error: `pievo: unknown command "${verb}" for the device credential (try: new, loops, pause, start, stop, delete, run stop, edit, log, show, file)` }
 			};
 		}
 	}
@@ -4998,7 +5027,7 @@ var CliGateway = class {
 	}
 	async requireStopProtocol(machineId, running) {
 		if (!running) return void 0;
-		if ((await getMachine(machineId))?.daemonProtocol === 4) return void 0;
+		if ((await getMachine(machineId))?.daemonProtocol === 5) return void 0;
 		return {
 			status: 426,
 			body: {
@@ -5109,121 +5138,90 @@ var CliGateway = class {
 			body: { text: `run already finished: ${runResultToken(stopped)}` }
 		};
 	}
-	async runCli(runToken, argv) {
-		const lease = await resolveLease(runToken);
-		if (!lease) return {
+	async runCli(runToken, _argv) {
+		if (!await resolveLease(runToken)) return {
 			status: 401,
 			body: {
 				text: errorBlock("invalid or expired token", "UNAUTHORIZED"),
 				exitCode: 1
 			}
 		};
-		if (lease.state === "terminal-grace" || lease.state === "reconciliation-only") return {
-			status: 409,
-			body: {
-				text: errorBlock(TERMINAL_GRACE_MSG, "CONFLICT"),
-				exitCode: 1
-			}
-		};
-		const verb = argv[0] ?? "";
-		const flags = parseFlags(argv.slice(1));
-		if (DEVICE_ONLY_VERBS.has(verb)) return {
-			status: 403,
-			body: {
-				text: errorBlock(`"${verb}" needs the device credential (owner authority); a run may only report`, "FORBIDDEN"),
-				exitCode: 1
-			}
-		};
-		if (flags.help === true && verb === "report") return {
-			status: 200,
-			body: {
-				text: verbHelpText("report", lease),
-				exitCode: 0
-			}
-		};
-		if (verb !== "report" && verb !== "help" && verb !== "--help" && verb !== "-h" && verb !== "") return {
+		return {
 			status: 403,
 			body: {
-				text: errorBlock("run credentials authorize only pievo report", "FORBIDDEN"),
+				text: errorBlock(RUN_HAS_NO_CLI, "FORBIDDEN"),
 				exitCode: 1
 			}
 		};
-		const out = await this.dispatch(lease, createHash("sha256").update(runToken).digest("hex"), argv);
-		return {
-			status: out.code,
-			body: {
-				text: out.text,
-				exitCode: out.code === 200 ? 0 : 1
-			}
-		};
 	}
-	async dispatch(lease, leaseTokenHash, argv) {
-		const verb = argv[0];
-		const flags = parseFlags(argv.slice(1));
-		const str = (key) => typeof flags[key] === "string" ? flags[key] : void 0;
-		if (verb === void 0 || verb === "" || verb === "-h" || verb === "--help" || verb === "help") return {
-			code: 200,
-			text: this.helpText(lease)
+	/** `file list|get|set` over one loop's files. `set` takes base64 content so
+	*  arbitrary text (including leading `--`) survives argv transport. */
+	async ownerFile(machineId, argv) {
+		const [, sub, loopId, name] = argv;
+		const loop = loopId ? await this.ownedLoop(machineId, loopId) : void 0;
+		if (sub !== "list" && sub !== "get" && sub !== "set") return {
+			status: 400,
+			body: { error: `usage: ${FILE_USAGE}` }
+		};
+		if (!loop) return {
+			status: 404,
+			body: { error: "no such loop on this machine" }
 		};
-		if (verb !== "report") return derr(403, "run credentials authorize only pievo report", "FORBIDDEN");
-		if (flags.help === true) return {
-			code: 200,
-			text: verbHelpText("report", lease)
+		const names = loopFileNames(loop);
+		if (sub === "list") return {
+			status: 200,
+			body: { text: doc(listBlock("files", [
+				"name",
+				"size",
+				"limit",
+				"updatedAt"
+			], await Promise.all(names.map(async (file) => {
+				const row = await getArtifactFile(loop.id, file);
+				const live = row && !row.deleted && row.hash ? row : void 0;
+				return [
+					file,
+					live?.size ?? 0,
+					fileLimitLabel(file),
+					live ? fmtTime(live.updatedAt) : null
+				];
+			}))), helpBlock([`Run \`pievo file get ${loop.id} <name>\` to print a file`, `Run \`pievo file set ${loop.id} <name> --from <path>\` to replace a file`])) }
 		};
-		const rawStatus = str("status");
-		const status = reportStatus(rawStatus);
-		if (!status) return derr(400, `status must be keep|no-change|block${rawStatus === void 0 ? "" : ` (got "${rawStatus}")`}`, "VALIDATION_ERROR");
-		const message = str("message")?.trim();
-		if (!message) return derr(400, "report requires a non-empty --message", "VALIDATION_ERROR");
-		const acceptedFlags = [
-			"status",
-			"message",
-			"help"
-		];
-		const unknown = Object.keys(flags).filter((key) => !acceptedFlags.includes(key));
-		if (unknown.length) return derr(400, `report does not accept --${unknown[0]}`, "VALIDATION_ERROR");
-		if (lease.state === "retired") return {
-			code: 200,
-			text: "reported: run retired · result discarded"
+		if (!name || !names.includes(name)) return {
+			status: 404,
+			body: { error: `no such loop file: ${name ?? ""} (files: ${names.join(", ")})` }
 		};
-		const applied = await this.applyReportMutation(lease, leaseTokenHash, status, message.slice(0, MESSAGE_CAP));
-		return applied.ok ? {
-			code: 200,
-			text: renderReportedText(status, true)
-		} : derr(applied.status ?? 409, applied.detail ?? "this run is no longer active", applied.code);
-	}
-	helpText(_lease) {
-		return doc(listBlock("verbs", ["verb", "syntax"], [["report", "--status keep|no-change|block --message <summary>"]]), helpBlock(["Call exactly one pievo report before finishing", "No other command is accepted from a run credential"]));
-	}
-	async applyReportMutation(lease, leaseTokenHash, status, message) {
-		const result = await recordRunReportOnce({
-			loopId: lease.loopId,
-			runId: lease.runId,
-			leaseTokenHash,
-			status,
-			message
-		});
-		if (result.state === "applied") return {
-			ok: true,
-			detail: "reported"
+		if (sub === "get") {
+			const row = await getArtifactFile(loop.id, name);
+			const bytes = await this.gateway.loopFiles.readBlob(row && !row.deleted && row.hash ? row.hash : EMPTY_SHA256);
+			if (!bytes) return {
+				status: 500,
+				body: { error: "loop file bytes are missing" }
+			};
+			return {
+				status: 200,
+				body: { text: bytes.length ? bytes.toString("utf8") : "\n" }
+			};
+		}
+		const encoded = parseFlags(argv.slice(4))["content-base64"];
+		if (typeof encoded !== "string") return {
+			status: 400,
+			body: { error: `usage: ${FILE_USAGE}` }
 		};
-		if (result.state === "missing-loop") return {
-			ok: false,
-			detail: "loop not found",
-			code: "NOT_FOUND",
-			status: 404
+		const bytes = Buffer.from(encoded, "base64");
+		const issue = loopFileIssue(name, bytes);
+		if (issue) return {
+			status: 413,
+			body: { error: `${issue}; nothing was changed` }
 		};
-		if (result.state === "already-reported") return {
-			ok: false,
-			detail: "this run already reported",
-			code: "CONFLICT",
-			status: 409
+		const hash = await this.gateway.loopFiles.putBlob(bytes);
+		if (hash !== "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855") await recordBlob(hash, bytes.length);
+		if (!await writeLoopFile(loop.id, name, hash, bytes.length)) return {
+			status: 404,
+			body: { error: "no such loop file" }
 		};
 		return {
-			ok: false,
-			detail: "this run is no longer active",
-			code: "CONFLICT",
-			status: 409
+			status: 200,
+			body: { text: `file: ${name}\nsize: ${bytes.length}\nupdated: true` }
 		};
 	}
 	async describe(loopId, opts = {}) {
@@ -5268,17 +5266,8 @@ var CliGateway = class {
 		})), scoped.elsewhere, await recentMachineRuns(loops, 3));
 	}
 };
-var TERMINAL_GRACE_MSG = "this run is terminal and no longer accepts commands; its final result is delivered via the terminal report";
-/** Verbs that require device authority. `report` is run-only and rejected there. */
-var DEVICE_ONLY_VERBS = new Set([
-	"new",
-	"edit",
-	"loops",
-	"start",
-	"stop",
-	"delete",
-	"run"
-]);
+var RUN_HAS_NO_CLI = "pievo commands are not available inside a run; end your final response with a summary and a last line `STATUS: keep|no-change|block`";
+var FILE_USAGE = "pievo file list <loop> | file get <loop> <name> | file set <loop> <name> --from <path>";
 var PAUSED_FINISHING = "loop paused; current run is finishing";
 var STOP_UPGRADE_REQUIRED = "Daemon upgrade required to stop a running process. Run `npm install -g @kky42/pievo@latest`, then `pievo daemon restart`.";
 var FORCE_DELETE_CONFIRMATION = "delete-server-data-anyway";
@@ -5316,15 +5305,6 @@ function parseJsonFlag(raw) {
 		value: obj
 	};
 }
-/** A structured `error:`/`code:` TOON result for stdout.
-*  Mirrors the `{code, text}` shape `dispatch` returns; the slug defaults from the
-*  HTTP status but a caller may pin it (e.g. CONFLICT). */
-function derr(code, message, slug) {
-	return {
-		code,
-		text: errorBlock(message, slug ?? codeForStatus(code))
-	};
-}
 /** The structured keys a `/api/machine/cli` body may carry. The daemon renders
 * `text` and exits with `exitCode`; two structured channels remain because the
 * current daemon reads them as data:
@@ -5352,18 +5332,6 @@ function finalizeCli(res) {
 	}
 	return res;
 }
-function renderReportedText(status, hasMessage) {
-	const parts = [];
-	if (status) parts.push(`status=${status}`);
-	if (hasMessage) parts.push("message recorded");
-	return `reported: ${parts.length ? parts.join(" · ") : "recorded"}`;
-}
-var RUN_VERB_HELP = { report: {
-	syntax: "report --status keep|no-change|block --message <text>",
-	summary: "record this run's required status and non-empty summary",
-	avail: () => "always available",
-	help: ["Run `pievo report --status no-change --message \"no actionable change\"` to close this run", "Run `pievo report --status keep --message \"completed the requested work\"` to retain a result"]
-} };
 var DEVICE_VERB_HELP = {
 	new: {
 		syntax: "new --json '<config>' [--dry-run]",
@@ -5402,24 +5370,29 @@ var DEVICE_VERB_HELP = {
 	},
 	delete: {
 		syntax: "delete <id> [--force]",
-		summary: "stop first, then delete server history and synced artifact metadata",
-		help: ["Stop this loop and delete its Pievo history and synced artifacts? Local project files are not deleted.", "--force requires a prior Delete request and explicit local confirmation; the local process may still be running"]
+		summary: "stop first, then delete server history, memory, and artifacts",
+		help: ["Stop this loop and delete its Pievo history, memory, and artifacts? Local project files are not deleted.", "--force requires a prior Delete request and explicit local confirmation; the local process may still be running"]
 	},
 	run: {
 		syntax: "run stop <run-id>",
 		summary: "stop one pending or running run without pausing its loop",
 		help: ["A running run remains running until the daemon confirms cancellation"]
 	},
+	file: {
+		syntax: "file list <id> | file get <id> <name> | file set <id> <name> --from <path>",
+		summary: "inspect or replace a loop's MEMORY.md and artifact files",
+		help: ["Run `pievo file get <id> MEMORY.md` to read the loop's memory", "An edit made while a run is executing wins over that run's version of the file"]
+	},
 	log: {
 		syntax: "log [<id>] [--limit 1..20] [--since ISO] [--until ISO] [--status keep|no-change|block] [--phase done|error|canceled] [--run <index|UUID> [--diff]] [--json]",
 		summary: "bounded terminal history or one detailed run",
 		help: ["Run `pievo log <id> --json` for structured history", "Run `pievo log <id> --run 12 --diff` for bounded run detail and artifact diff"]
 	}
 };
-function verbHelpText(verb, lease) {
-	const spec = lease ? RUN_VERB_HELP[verb] : DEVICE_VERB_HELP[verb];
+function verbHelpText(verb) {
+	const spec = DEVICE_VERB_HELP[verb];
 	if (!spec) return void 0;
-	return doc(kvLine("verb", verb), kvLine("syntax", spec.syntax), kvLine("summary", spec.summary), lease && spec.avail ? kvLine("availability", spec.avail(lease)) : null, helpBlock(spec.help));
+	return doc(kvLine("verb", verb), kvLine("syntax", spec.syntax), kvLine("summary", spec.summary), helpBlock(spec.help));
 }
 function loopEnvelope(loop) {
 	return { ...canonicalLoopEnvelope(loop) };
@@ -5456,7 +5429,8 @@ function renderShowText(loop, env, totalRuns, lastRun, opts = {}) {
 	const help = [
 		`Run \`pievo show ${loop.id} --full\` to see the complete prompt`,
 		`Run \`pievo edit ${loop.id} --json '{"schedule":{"mode":"continuous","delayMinutes":5}}'\` to change the schedule`,
-		`Run \`pievo log ${loop.id}\` to see recent run results`
+		`Run \`pievo log ${loop.id}\` to see recent run results`,
+		`Run \`pievo file list ${loop.id}\` to see the loop's memory and artifact files`
 	];
 	return doc(block, kvLine("nextFire", nextFireDisplay(loop)), `lifecycle: ${loop.enabled ? "active" : "paused"}`, `runs: ${runsTally}`, !loop.enabled ? kvLine("pauseCause", loop.pauseCause?.kind === "failure-streak" ? `failure-streak (run ${loop.pauseCause.runId}, count ${loop.pauseCause.count})` : loop.pauseCause?.kind === "blocked" ? `blocked (run ${loop.pauseCause.runId})` : loop.pauseCause?.kind === "owner" ? "owner" : "unknown") : null, lastRun?.reportIncident ? kvLine("reportIncident", `${lastRun.reportIncident.code} · ${lastRun.reportIncident.faultDomain} · ${lastRun.reportIncident.reason}`) : null, helpBlock(help));
 }
@@ -5544,9 +5518,6 @@ function renderHomeText(ctx, presence, here, elsewhere, recent) {
 		"Run `pievo new --json '{...}'` to create a loop"
 	]));
 }
-function reportStatus(s) {
-	return s === "keep" || s === "no-change" || s === "block" ? s : void 0;
-}
 /** Tiny flag parser: `--k v` pairs, bare `--flag` → true, first positional under `_`.
 *  Every key/value is NUL-stripped at this wire boundary before validation or
 *  persistence because Postgres text rejects NUL. */
@@ -5687,9 +5658,9 @@ function msg(err) {
 */
 var boot_exports = /* @__PURE__ */ __exportAll({
 	ensureServer: () => ensureServer,
-	getArtifactSync: () => getArtifactSync,
 	getCliGateway: () => getCliGateway,
-	getGateway: () => getGateway
+	getGateway: () => getGateway,
+	getLoopFiles: () => getLoopFiles
 });
 var g = globalThis;
 function ensureServer() {
@@ -5714,9 +5685,7 @@ async function boot() {
 	};
 	let gateway;
 	const scheduler = new Scheduler({ dispatch: (loop) => gateway.dispatcher.dispatch(loop) });
-	const blobStore = createBlobStore();
-	gateway = new MachineGateway(scheduler, blobStore);
-	const artifactSync = new ArtifactSync(blobStore);
+	gateway = new MachineGateway(scheduler, createBlobStore());
 	const cliGateway = new CliGateway(gateway);
 	await scheduler.start(abort.signal);
 	const sweep = setInterval(() => void gateway.sweep().catch((err) => logger.error({ err: String(err) }, "sweep tick failed")), ONLINE_TTL_MS);
@@ -5729,7 +5698,6 @@ async function boot() {
 	return {
 		scheduler,
 		gateway,
-		artifactSync,
 		cliGateway,
 		abort,
 		shutdown
@@ -5738,11 +5706,11 @@ async function boot() {
 async function getGateway() {
 	return (await ensureServer()).gateway;
 }
-async function getArtifactSync() {
-	return (await ensureServer()).artifactSync;
+async function getLoopFiles() {
+	return (await ensureServer()).gateway.loopFiles;
 }
 async function getCliGateway() {
 	return (await ensureServer()).cliGateway;
 }
 //#endregion
-export { listMachines as A, reconciliationStatesForRuns as B, getMachine as C, isOutdated as D, hasRunningRun as E, machineIdFromToken as F, startLoop as G, requestRunCancel as H, machinePresence as I, updateLoop as J, stopLoop as K, mintDeviceToken as L, listRunsBefore as M, loopTags_C6vATFCp_exports as N, listArtifacts as O, loopsForMachine as P, pauseLoop as R, getLoop as S, hasPendingRun as T, safeRelPath as U, requestDeleteLoop as V, sha256 as W, validateLoopTags as X, updateMachine as Y, countRuns as _, canonicalLoopEnvelope as a, forceDeleteMachine as b, ensureServer as c, readJsonBody as d, validOptionalPollString as f, CODING_AGENTS as g, validateLoopEdit as h, boot_CYRi_wez_exports as i, listRuns as j, listLoops as k, getArtifactSync as l, validPollWireId as m, MIN_DAEMON_VERSION as n, canonicalLoopSummary as o, validPollCurrentRun as p, tryDeleteLoop as q, POLL_HTTP_BODY_FIELDS as r, daemonNeedsUpdate as s, MACHINE_BODY_CAP as t, readByteBody as u, createMachine as v, getRun as w, getArtifactFile as x, forceDeleteLoop as y, recentLoopUsage as z };
+export { listRuns as A, requestDeleteLoop as B, getRun as C, listArtifacts as D, isOutdated as E, machinePresence as F, tryDeleteLoop as G, sha256 as H, mintDeviceToken as I, validateLoopTags as J, updateLoop as K, pauseLoop as L, loopTags_CnVLi70h_exports as M, loopsForMachine as N, listLoops as O, machineIdFromToken as P, recentLoopUsage as R, getMachine as S, hasRunningRun as T, startLoop as U, requestRunCancel as V, stopLoop as W, createMachine as _, canonicalLoopSummary as a, getArtifactFile as b, getLoopFiles as c, validOptionalPollString as d, validPollCurrentRun as f, countRuns as g, CODING_AGENTS as h, canonicalLoopEnvelope as i, listRunsBefore as j, listMachines as k, readByteBody as l, validateLoopEdit as m, POLL_HTTP_BODY_FIELDS as n, daemonNeedsUpdate as o, validPollWireId as p, updateMachine as q, boot_DmpKtb0A_exports as r, ensureServer as s, MIN_DAEMON_VERSION as t, readJsonBody as u, forceDeleteLoop as v, hasPendingRun as w, getLoop as x, forceDeleteMachine as y, reconciliationStatesForRuns as z };